Python 爬虫编程实践 Task【2】——BeautifulSoup库入门，Xpath，正则表达式 re

最新推荐文章于 2024-07-04 22:59:03 发布

ZHuZ1H

最新推荐文章于 2024-07-04 22:59:03 发布

阅读量1.3k

点赞数

分类专栏： Python 爬虫文章标签： python 爬虫 html 数据挖掘正则表达式

本文链接：https://blog.csdn.net/Jupiker/article/details/105720832

版权

Python 爬虫专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、BeautifulSoup库

1、BeautifulSoup的概念和入门

什么是 BeautifulSoup？

Beautiful Soup 是一个HTML/XML 的解析器，主要用于解析和提取 HTML/XML 数据。它基于HTML DOM的，会载入整个文档，解析整个DOM树，因此时间和内存开销都会大很多，所以性能要低于lxml。
BeautifulSoup 用来解析 HTML 比较简单，API非常人性化，支持CSS选择器、Python标准库中的HTML解析器，也支持 lxml 的 XML解析器。
虽然说BeautifulSoup4 简单容易比较上手，但是匹配效率还是远远不如正则以及xpath的，一般不推荐使用，推荐正则的使用。

安装和导入 BeautifulSoup

第一步：如果使用 Anaconda Jupyter Notebook 可以直接打开 Anaconda Powershell Prompt（或者 Anaconda Prompt），然后输入 conda install beautifulsoup4（这里是因为版本问题，只能安装bs4，其他的都会报错）。如果使用 IDLE 可以打开命令指示符（cmd），然后用 pip 来更新：pip install beautifulsoup4。安装完成之后就到下一步。
第二步：使用这个bs库之前需要引用：from bs4 import BeautifulSoup。
第三步：创建 Beautiful Soup对象 soup = BeautifulSoup(html，'html.parser')。

2、BS4库的基本元素

Beautiful Soup库的理解： Beautiful Soup库是解析、遍历、维护“标签树”的功能库，对应一个HTML/XML文档的全部内容
BeautifulSoup类的基本元素:

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

下面我们用代码来详细介绍这些元素。我们有一个Demo网址，现在开始尝试爬取上面的数据吧。
下面是网址界面和开发者工具（F12）
爬取代码如下：

# 导入bs4库
from bs4 import BeautifulSoup
import requests # 抓取页面

r = requests.get('https://python123.io/ws/demo.html') # Demo网址
demo = r.text  # 抓取的数据
demo

# 解析HTML页面
soup = BeautifulSoup(demo, 'html.parser')  # 抓取的页面数据；bs4的解析器
# 有层次感的输出解析后的HTML页面
print(soup.prettify())

1）标签，用soup.<tag>访问获得:

当HTML文档中存在多个相同<tag>对应内容时，soup.<tag>返回第一个

soup.a # 访问标签a
# <a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>

soup.title
# <title>This is a python demo page</title>

2）标签的名字:每个<tag>都有自己的名字，通过soup.<tag>.name获取，字符串类型

soup.a.name
# 'a'

soup.a.parent.name
# 'p'

soup.p.parent.name
# 'body'

3）标签的属性,一个<tag>可以有0或多个属性，字典类型，soup.<tag>.attrs

tag = soup.a
print(tag.attrs)  # {'href': 'http://www.icourse163.org/course/BIT-268001', 'class': ['py1'], 'id': 'link1'}  
print(tag.attrs['class'])  # ['py1']
print(type(tag.attrs))  # <class 'dict'>

4）Attributes:标签内非属性字符串,格式：soup.<tag>.string，NavigableString可以跨越多个层次

print(soup.a.string)  # Basic Python
print(type(soup.a.string))  # <class 'bs4.element.NavigableString'>

5）NavigableString:标签内字符串的注释部分，Comment是一种特殊类型(有–>)

print(type(soup.p.string))
# <class 'bs4.element.NavigableString'>

6）.prettify()为HTML文本<>及其内容增加更加’\n’，有层次感的输出

.prettify()可用于标签，方法：<tag>.prettify()

print(soup.prettify())
'''
<html>
 <head>
  <title>
   This is a python demo page
  </title>
 </head>
 <body>
  <p class="title">
   <b>
    The demo python introduces several python courses.
   </b>
  </p>
  <p class="course">
   Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
   <a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">
    Basic Python
   </a>
   and
   <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">
    Advanced Python
   </a>
   .
  </p>
 </body>
</html>
'''

print(soup.a.prettify())
'''
<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">
 Basic Python
</a>
'''

7）bs4库将任何HTML输入都变成utf‐8编码

Python 3.x默认支持编码是utf‐8,解析无障碍

newsoup = BeautifulSoup('<a>中文</a>', 'html.parser')
print(newsoup.prettify())
'''
<a>
 中文
</a>
'''

3、基于BS4库的HTML内容遍历方法

HTML基本格式:<>…</>构成了所属关系，形成了标签的树形结构
标签树的下行遍历
- .contents 子节点的列表，将<tag>所有儿子节点存入列表
- .children 子节点的迭代类型，与.contents类似，用于循环遍历儿子节点
- .descendants 子孙节点的迭代类型，包含所有子孙节点，用于循环遍历
标签树的上行遍
- .parent 节点的父亲标签
- .parents 节点先辈标签的迭代类型，用于循环遍历先辈节点
标签树的平行遍历
- .next_sibling 返回按照HTML文本顺序的下一个平行节点标签
- .previous_sibling 返回按照HTML文本顺序的上一个平行节点标签
- .next_siblings 迭代类型，返回按照HTML文本顺序的后续所有平行节点标签
- .previous_siblings 迭代类型，返回按照HTML文本顺序的前续所有平行节点标签

标签树的下行遍历

import requests
from bs4 import BeautifulSoup

r=requests.get('http://python123.io/ws/demo.html')
demo=r.text
soup=BeautifulSoup(demo,'html.parser')

print(soup.contents)# 获取整个标签树的儿子节点
'''
[<html><head><title>This is a python demo page</title></head>
<body>
<p class="title"><b>The demo python introduces several python courses.</b></p>
<p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a> and <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>.</p>
</body></html>]
'''

print(soup.body.content)#返回标签树的body标签下的节点
# None

print(soup.head)#返回head标签
# <head><title>This is a python demo page</title></head>

for child in soup.body.children:#遍历儿子节点
    print(child)
'''


<p class="title"><b>The demo python introduces several python courses.</b></p>


<p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a> and <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>.</p>


'''

for child in soup.body.descendants:#遍历子孙节点
    print(child)
'''


<p class="title"><b>The demo python introduces several python courses.</b></p>
<b>The demo python introduces several python courses.</b>
The demo python introduces several python courses.


<p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a> and <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>.</p>
Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:

<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>
Basic Python
 and 
<a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>
Advanced Python
.


'''

标签树的上行遍历

soup.title.parent
# <head><title>This is a python demo page</title></head>

soup.parent
for parent in soup.a.parents: # 遍历先辈的信息
    if parent is None:
        print(parent)
    else:
        print(parent.name)
'''
p
body
html
[document]
'''

标签树的平行遍历

标签树的平行遍历是有条件的
平行遍历发生在同一个父亲节点的各节点之间
标签中的内容也构成了节点

print(soup.a.next_sibling)#a标签的下一个标签
#  and 

print(soup.a.next_sibling.next_sibling)#a标签的下一个标签的下一个标签
# <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>

print(soup.a.previous_sibling)#a标签的前一个标签
# Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:

print(soup.a.previous_sibling.previous_sibling)#a标签的前一个标签的前一个标签
# None

for sibling in soup.a.next_siblings:#遍历后续节点
    print(sibling)
'''
 and 
<a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>
.
'''

for sibling in soup.a.previous_sibling:#遍历之前的节点
    print(sibling)
'''
P
y
t
h
o
n
 
i
s
 
a
.......
'''

4、基于BS4库的HTML内容的查找方法

<>.find_all(name, attrs, recursive, string, **kwargs)
- 参数：
- ∙ name : 对标签名称的检索字符串
- ∙ attrs: 对标签属性值的检索字符串，可标注属性检索
- ∙ recursive: 是否对子孙全部检索，默认True
- ∙ string: <>…</>中字符串区域的检索字符串
  - 简写：
  - <tag>(…) 等价于 <tag>.find_all(…)
  - soup(…) 等价于 soup.find_all(…)
扩展方法：
- <>.find() 搜索且只返回一个结果，同.find_all()参数
- <>.find_parents() 在先辈节点中搜索，返回列表类型，同.find_all()参数
- <>.find_parent() 在先辈节点中返回一个结果，同.find()参数
- <>.find_next_siblings() 在后续平行节点中搜索，返回列表类型，同.find_all()参数
- <>.find_next_sibling() 在后续平行节点中返回一个结果，同.find()参数
- <>.find_previous_siblings() 在前序平行节点中搜索，返回列表类型，同.find_all()参数
- <>.find_previous_sibling() 在前序平行节点中返回一个结果，同.find()参数

import requests
from bs4 import BeautifulSoup

r = requests.get('http://python123.io/ws/demo.html')
demo = r.text
soup = BeautifulSoup(demo,'html.parser')
soup
'''
<html><head><title>This is a python demo page</title></head>
<body>
<p class="title"><b>The demo python introduces several python courses.</b></p>
<p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a> and <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>.</p>
</body></html>
'''

# name : 对标签名称的检索字符串
soup.find_all('a')
'''
 [<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>,
 <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>]
'''

soup.find_all(['a', 'p'])
'''
[<p class="title"><b>The demo python introduces several python courses.</b></p>,
 <p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
 <a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a> and <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>.</p>,
 <a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>,
 <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>]
'''

# attrs: 对标签属性值的检索字符串，可标注属性检索
soup.find_all("p","course")
'''
[<p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
 <a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a> and <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>.</p>]
'''

soup.find_all(id="link") # 完全匹配才能匹配到
# []

#  recursive: 是否对子孙全部检索，默认True
soup.find_all('p',recursive=False)
# []

# string: <>…</>中字符串区域的检索字符串
soup.find_all(string = "Basic Python") # 完全匹配才能匹配到
# ['Basic Python']

5、BS库爬虫实战：中国大学排名定向爬取

要爬取的url：http://www.zuihaodaxue.cn/zuihaodaxuepaiming2019.html
页面和开发者工具如下：

# 首先先导入库
import requests
from bs4 import BeautifulSoup
import bs4

从网络上获取大学排名网页内容

def getHTMLText(url):
    try:
        r = requests.get(url, timeout=30) # 限定时间，若访问超时，则退出
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return ""

提取网页内容中信息到合适的数据结构（二维数组）

查看网页源代码，观察并定位到需要爬取内容的标签；
使用bs4的查找方法提取所需信息-‘排名，学校名称，总分’

我们从开发者工具中找到我们所需要返回的信息，这个我已经在上图中举例标出，其他大学都是一样，所以我们找出规律，写出下面的函数。

def fillUnivList(ulist, html):
    soup = BeautifulSoup(html, "html.parser")  # 解析页面
    for tr in soup.find('tbody').children: 
        if isinstance(tr, bs4.element.Tag):
            tds = tr('td')
            # 根据实际提取需要的内容，
            ulist.append([tds[0].string, tds[1].string, tds[3].string])  
            # 对应相应位置。

利用数据结构展示并输出结果

# 对中英文混排输出问题进行优化:对format()，设定宽度和添加参数chr(12288)
def printUnivList(ulist, num=20):
    tplt = "{0:^10}\t{1:{3}^10}\t{2:^10}"
    print(tplt.format('排名', '学校名称', '总分', chr(12288)))
    for i in range(num):
        u = ulist[i]
        print(tplt.format(u[0], u[1], u[2], chr(12288)))

u_info = [] # 存储爬取结果的容器
url = 'http://www.zuihaodaxue.cn/zuihaodaxuepaiming2019.html'

html = getHTMLText(url)  # 网页源码
html

fillUnivList(u_info, html) # 爬取

printUnivList(u_info, num=30) # 打印输出30个信息

二、Xpath

1、Xpath常用的路径表达式：

XPath即为XML路径语言（XML Path Language），它是一种用来确定XML文档中某部分位置的语言。
在XPath中，有七种类型的节点：元素、属性、文本、命名空间、处理指令、注释以及文档（根）节点。
XML文档是被作为节点树来对待的。

XPath使用路径表达式在XML文档中选取节点。节点是通过沿着路径选取的。下面列出了最常用的路径表达式：

nodename 选取此节点的所有子节点。
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。
. 选取当前节点。
… 选取当前节点的父节点。
@ 选取属性。
/text() 提取标签下面的文本内容

/标签名逐层提取
/标签名提取所有名为<>的标签
//标签名[@属性=“属性值”] 提取包含属性为属性值的标签
@属性名代表取某个属性名的属性值

2、使用lxml解析

导入库：from lxml import etree
lxml将html文本转成xml对象：tree = etree.HTML(html)
用户名称：tree.xpath(’//div[@class=“auth”]/a/text()’)
回复内容：tree.xpath(’//td[@class=“postbody”]’) 因为回复内容中有换行等标签，所以需要用string()来获取数据。
Xpath中text()，string()，data()的区别如下：
- text()仅仅返回所指元素的文本内容。
- string()函数会得到所指元素的所有节点文本内容，这些文本讲会被拼接成一个字符串。
- data()大多数时候，data()函数和string()函数通用，而且不建议经常使用data()函数，有数据表明，该函数会影响XPath的性能。

3、Xpath爬虫实战：爬取丁香园-用户名和回复内容

下面是网站页面和开发者工具：

找到要返回的信息。

首先导入库

# 导入库
from lxml import etree
import requests

url = "http://www.dxy.cn/bbs/thread/626626#626626"  # 要爬取的网址

获取url的html

req = requests.get(url)
html = req.text
# html

lxml解析html

tree = etree.HTML(html) 
tree
# <Element html at 0x2313e5ac188>

利用Xpath表达式获取user和content（重点）

user = tree.xpath('//div[@class="auth"]/a/text()')
# print(user)
content = tree.xpath('//td[@class="postbody"]')

保存爬取的内容

results = []
for i in range(0, len(user)):
    # print(user[i].strip()+":"+content[i].xpath('string(.)').strip())
    # print("*"*80)
    # 因为回复内容中有换行等标签，所以需要用string()来获取数据
    results.append(user[i].strip() + ":  " + content[i].xpath('string(.)').strip())

# 打印爬取的结果
for i,result in zip(range(0, len(user)),results):
    print("user"+ str(i+1) + "-" + result)
    print("*"*100)

三、正则表达式 re

1、为什么使用正则表达式？

典型的搜索和替换操作要求您提供与预期的搜索结果匹配的确切文本。虽然这种技术对于对静态文本执行简单搜索和替换任务可能已经足够了，但它缺乏灵活性，若采用这种方法搜索动态文本，即使不是不可能，至少也会变得很困难。

通过使用正则表达式，可以：

测试字符串内的模式。例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。
替换文本。可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。
基于模式匹配从字符串中提取子字符串。可以查找文档内或输入域内特定的文本，也可以使用正则表达式来搜索和替换标记。

使用正则表达式的优势是什么？ 简洁

正则表达式是用来简洁表达一组字符串的表达式
正则表达式是一种通用的字符串表达框架
正则表达式是一种针对字符串表达“简洁”和“特征”思想的工具
正则表达式可以用来判断某字符串的特征归属

正则表达式在文本处理中十分常用：

同时查找或替换一组字符串
匹配字符串的全部或部分(主要)

2、正则表达式语法

正则表达式语法由字符和操作符构成:

常用操作符
- . 表示任何单个字符
- [ ] 字符集，对单个字符给出取值范围，如[abc]表示a、b、c，[a‐z]表示a到z单个字符
- [^ ] 非字符集，对单个字符给出排除范围，如[^abc]表示非a或b或c的单个字符
- * 前一个字符0次或无限次扩展，如abc* 表示 ab、abc、abcc、abccc等
- + 前一个字符1次或无限次扩展，如abc+ 表示 abc、abcc、abccc等
- ? 前一个字符0次或1次扩展，如abc? 表示 ab、abc
- | 左右表达式任意一个，如abc|def 表示 abc、def
- {m} 扩展前一个字符m次，如ab{2}c表示abbc
- {m,n} 扩展前一个字符m至n次（含n），如ab{1,2}c表示abc、abbc
- ^ 匹配字符串开头，如^abc表示abc且在一个字符串的开头
- $ 匹配字符串结尾，如abc$表示abc且在一个字符串的结尾
- ( ) 分组标记，内部只能使用 | 操作符，如(abc)表示abc，(abc|def)表示abc、def
- \d 数字，等价于[0‐9]
- \w 单词字符，等价于[A‐Za‐z0‐9_]

3、正则表达式re库的使用

调用方式：import re
re库采用raw string类型表示正则表达式，表示为：r'text'，raw string是不包含对转义符再次转义的字符串;

re库的主要功能函数：

re.search() 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
- re.search(pattern, string, flags=0)
re.match() 从一个字符串的开始位置起匹配正则表达式，返回match对象
- re.match(pattern, string, flags=0)
re.findall() 搜索字符串，以列表类型返回全部能匹配的子串
- re.findall(pattern, string, flags=0)
re.split() 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
- re.split(pattern, string, maxsplit=0, flags=0)
re.finditer() 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
- re.finditer(pattern, string, flags=0)
re.sub() 在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
- re.sub(pattern, repl, string, count=0, flags=0)
- flags : 正则表达式使用时的控制标记：
  - re.I --> re.IGNORECASE : 忽略正则表达式的大小写，[A‐Z]能够匹配小写字符
  - re.M --> re.MULTILINE : 正则表达式中的^操作符能够将给定字符串的每行当作匹配开始
  - re.S --> re.DOTALL : 正则表达式中的.操作符能够匹配所有字符，默认匹配除换行外的所有字符

re库的另一种等价用法（编译）

regex = re.compile(pattern, flags=0)：将正则表达式的字符串形式编译成正则表达式对象

re 库的贪婪匹配和最小匹配

.* Re库默认采用贪婪匹配，即输出匹配最长的子串
*? 只要长度输出可能不同的，都可以通过在操作符后增加，变成最小匹配

4、re爬虫实战：淘宝商品比价定向爬虫

爬取网址：https://s.taobao.com/search?q=书包&js=1&stats_click=search_radio_all%25

# 导入包
import requests
import re

提交商品搜索请求，循环获取页面

def getHTMLText(url):
    """
    请求获取html，（字符串）
    :param url: 爬取网址
    :return: 字符串
    """
    try:
        # 添加头信息,不同人cookie不同，需要自己找到自己的cookie。
        kv = {
            'cookie': '_samesite_flag_=true; cookie2=1e9bcf4ff1096d63ca7b6796617d4b95; t=74c29e7a4799e99836062f500a4854ab; _tb_token_=3befb9e37565e; sgcookie=EQMlGbpaAS8%2Fzd75R6nb0; tfstk=c5kPB7a5FLpyCd9x68eUVqVDtkVRa0z35traZf5vips15BF87sqFJoxfJorUWKVl.; enc=16rMr2peT6BrrBcGGDgNmhz3q8AQRT4Kx1BNHe8YCnNl%2BRLAUqIgtX8ZxJmzW34shMDIN9l90s5%2BPsP2jgskDw%3D%3D; hng=CN%7Czh-CN%7CCNY%7C156; thw=cn; alitrackid=localhost; lastalitrackid=localhost; mt=ci=0_0; tracknick=; cna=NF3mFoiUTnICAXFblzrGEp9Y; JSESSIONID=BD565CCBD5EAA98BDE7A83489932F087; isg=BCQkkVuDJjZQvVJ6WKzw1MDo9SIWvUgnrkQ-TD5FTu-y6cOzZ8lstxILqUFxMYB_; l=eBa8FzMVQ2RQ7y2tBO5wlurza77OXIRffsPzaNbMiIHca6MctFgDrNQcc5xXSdtjgtfbseKyCyL76RhMPMzd02HvCbKrCyCkWxJe-',
            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.162 Safari/537.36'
        }
        r = requests.get(url, timeout=30, headers=kv)
        # r = requests.get(url, timeout=30)
        # print(r.status_code)
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return "爬取失败"

这里需要注意一点！！！！
不同人的头信息是不一样的，就是上面的 cookie ，我们需要填写自己的 cookie ，否则是无法爬虫成功的。下面说下怎么找这个cookie。

这里先查找一次书包，刷新网页就会在开发者工具中的Network中出现 search开头的Name，里面Request Headers中就有cookie，我们复制粘贴到上面代码的相应位置即可。

对于每个页面，提取商品名称和价格信息

def parsePage(glist, html):
    '''
    解析网页，搜索需要的信息
    :param glist: 列表作为存储容器
    :param html: 由getHTMLText()得到的
    :return: 商品信息的列表
    '''
    try:
        # 使用正则表达式提取信息
        #商品价格
        price_list = re.findall(r'\"view_price\"\:\"[\d\.]*\"', html)
        #商品名称
        name_list = re.findall(r'\"raw_title\"\:\".*?\"', html)
        for i in range(len(price_list)):
            price = eval(price_list[i].split(":")[1])  #eval（）在此可以去掉""
            name = eval(name_list[i].split(":")[1])
            glist.append([price, name])
    except:
        print("解析失败")

将信息输出到屏幕上

def printGoodList(glist):
    tplt = "{0:^4}\t{1:^6}\t{2:^10}"
    print(tplt.format("序号", "商品价格", "商品名称"))
    count = 0
    for g in glist:
        count = count + 1
        print(tplt.format(count, g[0], g[1]))

# 根据页面url的变化寻找规律，构建爬取url
goods_name = "书包"  # 搜索商品类型
start_url = "https://s.taobao.com/search?q=" + goods_name
info_list = []
page = 3  # 爬取页面数量

count = 0
for i in range(page):
    count += 1
    try:
        url = start_url + "&s=" + str(44 * i)
        html = getHTMLText(url)  # 爬取url
        parsePage(info_list, html) #解析HTML和爬取内容
        print("\r爬取页面当前进度: {:.2f}%".format(count * 100 / page), end="")  # 显示进度条
    except:
        continue

直到爬取成功，也就是上面进度到达100%。就可以输出数据了。

printGoodList(info_list)

如果刚好返回三页的书包数据时，说明爬虫成功！

四、备注

源代码：
https://github.com/ZHUZH-GOJMZ/Python-Web-Crawler-Learning/blob/master/Python%20%E7%88%AC%E8%99%AB%E7%BC%96%E7%A8%8B%E5%AE%9E%E8%B7%B5%20Task%202%20SourseCode.ipynb

参考学习网址：
基于bs4库的HTML内容遍历方法：https://www.cnblogs.com/mengxiaoleng/p/11585754.html#_label0

Xpath常用的路径表达式：https://www.cnblogs.com/gaojun/archive/2012/08/11/2633908.html

string()：https://www.cnblogs.com/CYHISTW/p/12312570.html

参考教程：
https://github.com/ZHUZH-GOJMZ/team-learning/blob/master/Python%E7%88%AC%E8%99%AB%E7%BC%96%E7%A8%8B%E5%AE%9E%E8%B7%B5/task2/Task%2002%20%20bs4.ipynb

https://github.com/ZHUZH-GOJMZ/team-learning/blob/master/Python%E7%88%AC%E8%99%AB%E7%BC%96%E7%A8%8B%E5%AE%9E%E8%B7%B5/task2/Task%2002%20%20Xpath.ipynb

https://github.com/ZHUZH-GOJMZ/team-learning/blob/master/Python%E7%88%AC%E8%99%AB%E7%BC%96%E7%A8%8B%E5%AE%9E%E8%B7%B5/task2/Task%2002%20re.ipynb

ZHuZ1H

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Python 爬虫编程实践 Task【2】——BeautifulSoup库入门，Xpath，正则表达式 re

目录一、BeautifulSoup库1、BeautifulSoup的概念和导入2、BS4库的基本元素3、基于BS4库的HTML内容遍历方法4、基于BS4库的HTML内容的查找方法5、BS库爬虫实战：中国大学排名定向爬取二、Xpath1、Xpath常用的路径表达式：2、使用lxml解析3、Xpath爬虫实战：爬取丁香园-用户名和回复内容三、正则表达式 re1、为什么使用正则表达式？2、正则表达式语法...
复制链接

扫一扫

专栏目录