Python网络爬虫与信息提取

于 2020-05-17 15:28:15 发布
阅读量4k 收藏 13
点赞数 1
分类专栏： Python 文章标签： python 正则表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43533083/article/details/106175071
版权

Python网络爬虫与信息提取

  • 掌握定向网络数据爬取和网页解析的基本能力

  • 几个部分：

    • Requests库的介绍，通过这个库克以自动爬取HTML页面，在网络上自动提交相关请求
    • robots.txt协议，网络爬虫的规则，网络爬虫排除标准
    • Beautiful Soup库，解析HTML页面提取相关信息
    • 实战项目Projects：A/B，了解库以及相关操作
    • Re正则表达式库：提取关键信息
    • Sctapy：专业网络爬虫的框架，第三方库，中规模速度更快的。

常用的PythonIDE工具

  • 文本工具类
    • IDLE
      • 自带的、默认的、常用的、入门级工具
      • 包含两种交互式和文件式
    • Sublime Text
      • 专门为程序员开发的第三方专用编程工具
      • 工具非注册免费使用
  • 集成工具类
    • wing
      • 公司委会，工具售给
      • 调试功能丰富
      • 版本控制，版本同步
      • 多人共同开发
    • Visual Studio & PTVS
      • 微软公司维护
      • win环境为主
      • 调试功能丰富
    • Eclipse & PyDev
      • 开源IDE开发工具
      • 需要有一定开发经验
    • PyCharm
      • 社区版免费
      • 加单，集成度高
      • 适合较复杂较大的开发
    • Canopy（科学计算数学分析）
      • 公司委会，工具收费
      • 支持近500个第三方库
      • 适合科学计算领域应用开发
    • Anaconda（科学计算数学分析）
      • 开源免费
      • 支持近800个第三方库

网络爬虫

一、Requests库入门

  • 特点：简单简洁，一行代码就可以获得相关信息

requests的安装方法

1.管理员权限启动cmd
2.输入pip install requests

requests库的七个主要方法

方法说明
requests.request()构造一个骑牛，支持一下各种方法的基础方法
requests.get()获取HTML网页的主要方法，对应于HTTP的GET
requests.head()获取HTML网页头信息的方法，对应于HTTP的HEAD
requests.post()向HTML网页提交POST请求的方法，对应于HEEP的POST
requests.put()向HTML网页提交PUT请求的方法，对应于HTTP的PUT
requests.patch()向HTML网页提交局部修改请求，对应于HTTP的PATCH
requests.delete()向HTML页面提交删除请求，对应于HEEP的DELETE

requests库中的get方法

1.通过r = requests.get(url)
Request对象：构造一个向服务器请求资源的Request对象（Requests库内部生成的）
Response对象：然后返回一个包含服务器资源的Response对象
2.r = requests.get(url，params=Node，** kwargs)
url:获取页面的url链接

params：url中的额外参数，字典或字节流格式，可选

** kwargs：12个控制访问的参数

3.Response对象的属性

属性说明
r.status_codeHTTP请求的返回状态，200表示连接成果，404表示连接失败
r.textHTTP相应内容的字符串形式，即url对应的页面内容
r.encoding从HTTP header中猜测的响应内容编码方式
r.apparent_encoding从内容中分析出的响应内容编码方式（备选编码方式）
r.contentHTTP相应内容的二进制形式

r.encoding:如果header中不存在charset,自认为编码为ISO-8859-1

r.apparent_encoding:根据网页内容分析出的编码方式

Requests库的异常

异常说明
requests.ConnectionError网络连接错误异常，如DNS查询失败、拒绝连接
requests.HTTPErrorHTTP错误异常
requests.URLRequiredURL缺失异常
requests.TooManyRedirects超过最大重定向次数，产生重定向异常
requests.ConnectTimeout连接远程服务器超时异常
requests.Timeout请求URL超时，产生超时异常
requests.raise_for_status()如果不是200，产生异常requests.HTTPError

HTTP协议以及Requests库方法

  • HTTP协议
    • HTTP，Hypertext Transfer Protocol，超文本传输协议，HTTP是一种基于“请求与响应”模式的、无状态的应用层协议。
      • 简单讲：用户发送请求，服务器返回响应。
      • 无状态：第一次与第二次之间没有关联
      • 应用层：该协议工作于HTP协议之上
    • HTTP协议采用URL作为网络资源的标识
    • URL格式：http://host[:post]_[path]
      • host：合法的Internet主机域名或IP地址
      • port：端口号，缺省端口为80
      • path：请求资源的路径
    • HTTP URL实例：http://www.bit.edu.cn
    • HTTP URL的理解：URL是ton过HTTP协议存取资源的一个Internet路径，一个URL对应一个数据资源
  • HTTP协议对资源的操作
方法说明
GET请求获取URL位置的资源
HEAD请求花去URL位置资源额响应消息报告，即获得非自愿的头部信息
POST请求向URL位置的资源后附加新的数据
PUT请求向URL位置存储一个资源，覆盖原URL位置的资源
PATCH请求局部更新URL位置的资源，即改变该处位置的资源
DELETE请求删除URL位置存储的资源

理解PATCH和PUT的区别

假设URL位置有一组数据UserInfo，包括UserID、UserName等20个字段。

需求：用户修改了UserName，其他不变

1.采用PATCH，进向URL提交UserName的局部更新请求

2.采用PUT，必须将所有20个字段一并提交到URL，未提交字段被删除

PATCH优点：节省网络带宽

  • HTTP协议与Requests库的方法是一致的

  • Requests库的head（）方法

r = requests.head('http://httpbin.org/get')
r.headers
#会有返回的信息，当执行
r.text
#没有返回信息，因为我们只获得了头部信息
  • Requests库的post（）方法
payload = {"key1":"vlaue1","key2":"value2"}
r = requests.post('http://httpbin.org/post',data=payload)
print(r.text)
#结果
{...
 "form":{
   	"key2":"value2",
    "key1":"value1" 
 }, 
}
#向URL POST一个字典（或者键值对）自动编码为form（表单）
#如果提交一个字符串就会自动编码为data
r = requests.post('http://httpbin.org/post',data='ABC')
print(r.text)
#结果
{...
    "data":"ABC"
 	"form":{},
}
  • Requests库中的put（）方法

与post（）方法效果不同，但是编码结果一样

Requests库主要方法解析

  • requests（method,url,**kwargs）方法

    • 是所有方法的基础方法

    • method：请求方式；对应get/put/post等7种

      • requests.request(‘GET’,url,**kwargs)

      • requests.request(‘HEAD’,url,**kwargs)

      • requests.request(‘POST’,url,**kwargs)

      • requests.request(‘PUT’,url,**kwargs)

      • requests.request(‘PATCH’,url,**kwargs)

      • requests.request(‘DELETE’,url,**kwargs)

      • requests.request(‘OPTIONS’,url,**kwargs),向服务器获取服务器和客户端打交道的参数，与获取资源并不直接相关。

    • url：获取页面的url链接

    • **kwargs：控制访问参数，13个

      • **开头表示可选的
      • params字典或字节序列，作为参数增加到url中
      kv = {"key1":"value1","key2":"value2"}
r = requests.request('GET','http://python123.io/ws',params=kv)
print(r.url)
#结果
http://python123.io/ws?key1=value1&key2=value2
      • data:字典、字节序列或文件对象，作为Request的内容，主要是向服务器提交资源时使用
      kv = {"key1":"value1","key2":"value2"}
r = requests.request('POST','http://python123.io/ws',data=kv)
body="主体内容"
r = requests.request('POST','http://python123.io/ws',data=body)
#结果并不是放在url链接里面而是放在url链接对应位置的地方作为数据来存储
      • json：JSON格式的数据作为Request的内容
      kv = {"key1":"value1"}
r = requests.request('POST','http://python123.io/ws',json=kv)
      • headers:字典，HTTP定制头
      hd={'user-agent':Chrome/10}
r = requests.request('POST','http://python123.io/ws',headers=hd)
      • cookies:字典或者CookieJar,Request中的cookie
      • auth：元组，支持HTTP认证功能
      • files：字典类型，传输文件
      fs = {'file':open("data.xls","rb")}
r = requests.request("POST",http://python123.io/ws,files=fs)
      • timeout:设定的超时时间，以秒为单位
      r = requests.request("GET",'http://www.baidu.com',timeout=10)
#在设定时间之内没有返回回来那么就会出现异常
      • proxies：字典类型，设定访问代理服务器，可以增加登录认证,防止对爬虫的你追踪，更换IP地址
      pxs = {'http':'http://user:pass@10.10.10.1:1234','https':'https://10.10.10.1:431'}
r = requests.request("GET",'http://www.baidu.com',proxies=pxs)
      • allow_redirects:True/False,默认为True，重定向开关，表示允不允许对URL进行重定向
      • stream：True/False,默认为True，是否对获取内容立即下载
      • verify：True/False,默认为True，认证SSL证书开关
      • cert：本地SSL证书路径

    • requests.get(url,params=None,**kwargs)

      • url:获取页面的URL连接
      • params：url中的额外参数，字典或字节流格式，可选
      • **kwargs：12个控制访问的参数

    • request.head(url,**kwargs)

    • request.post(url,data=None,json=None,**kwargs)

    • request.put(url,data=None,**kwargs)

    • request.patch(url,data=None,**kwargs)

    • request.delete(url,**kwargs)

    • request.get(url,params=None,**kwargs)

单元小结

  • request入门

    • requests.request()
    • requests.get()：常用
    • requests.head()：常用

    由于网络安全的限制以下方法很难实行

    • requests.post()
    • requests.put()
    • requests.patch()
    • requests.delete()

  • 爬取网页的通用代码框架

二、网络爬虫盗亦有道

网络爬虫引发的问题

  • 网络爬虫的尺寸
小规模，数据量小爬取速度不敏感Requests库（占比90+%）中规模，数据规模较大，爬取速度敏感，Scrapy库大规模，搜索引擎爬取速度关键，定制开发
爬取网页，玩转网页爬取网站爬取系列网站爬取全网
  • 网络爬虫的“骚扰”

web服务器默认只接受人类的访问，爬虫速度快（百倍）获取资源。

受限于编写水平和目的，网络爬虫将会为web服务器带来巨大的资源开销。

  • 法律风险

服务器上的数据有产权归属

网络爬虫获取数据后牟利将带来法律风险

  • 网络爬虫泄露隐私

网络爬虫可能具备突破简单访问控制的能力，获得被保护数据从而泄露个人隐私

  • 网络爬虫的限制
    • 来源审查：判断User-Agent进行限制（对网站的开发人员有一定的技术要求）
      • 检查来访HTTP协议头的User-Agent域，只响应浏览器或友好爬虫的访问
    • 发布公告：Robots协议（是否遵守有网络爬虫决定）
      • 告知所有爬虫网站的爬取策略，要求爬虫遵守。

Robots协议

  • Robots Exclusion Standard 网络爬虫排除标准
  • 作用：网站告知网络爬虫哪些页面可以抓取，那些不行
  • 形式：在网站的根目录下放置robots.txt文件（写了哪些可以爬那些不可以爬）
  • 例子：京东的网络爬虫协议
    User-agent: * 表示所有的爬虫都要遵循以下协议
    Disallow: /?* 不允许访问以问号开头的路径
    Disallow: /pop/.html 不允许访问/pop/.html
    Disallow: /pinpai/.html? 符合这个通配符的也是不允许访问的
    User-agent: EtaoSpider
    Disallow: / 不允许爬取任何资源
    User-agent: HuihuiSpider
    Disallow: /
    User-agent: GwdangSpider
    Disallow: /
    User-agent: WochachaSpider
    Disallow: /

Robots协议的遵守方式

  • Robots协议的使用
    • 网络爬虫：自动或人工识别robots.txt,在进行内容爬取。
    • Robots协议是建议单非约束性，网络爬虫可以不遵守，但是存在法律风险
  • 对Robots协议的理解
访问量很小：可以遵守，访问量很大：建议遵守非商业且偶尔：建议遵守，商业利益：必须遵守必须遵守
爬取网页，玩转网页爬取网站爬取系列网站爬取全网
  • 小程序，类似人类行为，可以不参考Robots协议，（访问次数少，访问量少）

三、Requests库爬取实例

实例1：京东商品页面的爬取

>>>import requests
>>> r = requests.get("https://item.jd.com/100012545852.html")
>>> r.status_code
>>> 200
>>> r.encoding
>>> 'UTF-8'
>>> r.text
>>> "undefined<script>window.location.href='https://passport.jd.com/uc/login?ReturnUrl=http://item.jd.com/100012545852.html'</script>"

实例二 亚马逊商品页面的爬取

>>> kv = {'user-agent':'Mozilla/5,0'}
>>> url = "https://www.amazon.cn/dp/B003L9T0YY/ref=s9_acsd_hps_bw_c2_x_1_t?pf_rd_m=A1U5RCOVU0NYF2&pf_rd_s=merchandised-search-2&pf_rd_r=YTFCRRW6DCAZD4XRW329&pf_rd_t=101&pf_rd_p=4ac46f0a-16da-4ce2-ac3b-60fc19884e37&pf_rd_i=2328555071"
>>> r = requests.get(url,headers=kv)
>>> r.status_code
200
>>> r.request.headers
{'user-agent': 'Mozilla/5,0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'}
>>> r.text[:1000]
#结果

实例三百度/360搜索关键词提交

  • 百度关键词接口：http://www.baidu.com/s?wd=keyword
  • 360的关键词接口:http://www.so.com/s?q=keyword
>>> import requests
>>> kv ={'wd':'python'}
>>> r = requests.get("http://www.baidu.com/s",params = kv)
>>> r.status_code
200
>>>r.text
#结果

实例四：网络图片的爬取和存储

  • 网络图片链接的格式：http://www.example.com/picture.jpg
  • 右键属性获得图片的真实地址
>>> import requests
>>> path = "D:/abc.jpg"
>>> url="http://pic.sc.chinaz.com/files/pic/pic9/202005/zzpic24970.jpg"
>>> r = requests.get(url)
>>> r.status_code
200
>>> with open(path,"wb") as f:
	f.write(r.content)

	
78178
>>> f.close()

实例五：IP地址归属地的自动查询

em…这个例子要用到ip138的功能，然而好像有防爬取措施，所以导致例子不能用…

四、Beautiful soup 库

Beautiful soup库的安装

pip install beautifulsoup4

小例子

demo = r.text
from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,"html.parser")
print(soup.prettify())

Beautiful Soup库的基本元素

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

  • Beautiful Soup的引用：

    • from bs4 import BeautifulSoup
    • import bs4

  • HTML文档—标签树—BeautifulSoup类：一 一对应

    • BeautifulSoup对应一个HTML、XML文档的全部内容

Beautiful Soup库解析器

解析器使用方法条件
bs4的HTML解析器BeautifulSoup（mk，“html.parser”）安装bs4库
lxml的HTML的解析器BeautifulSoup（mk，’lxml‘）pip install lxml
lxml的XML的解析器BeautifulSoup（mk，’xml‘）pip install lxml
html5lib的解析器BeautifulSoup（mk，’html5lib‘）pip install html5lib

Beautiful Soup类的基本元素

基本元素说明
Tag标签，最基本的信息组织单元，分别用<>和</>标明开头和结尾
Name标签的名字，

…

的名字的’p‘，格式：.name
Attributrs标签的属性，字典形式组织，格式：.attrs
NavigableString标签内非属性字符串，<>…</>,格式：.string
Comment标签内字符串的注释部分，一种特殊的Comment类型

Beautiful Soup库的理解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iBcrGZol-1589700353604)(C:\Users\60917\AppData\Roaming\Typora\typora-user-images\1589452938575.png)]

基于bs4库的HTML内容遍历方法

  • HTML基本格式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eU3kAsEi-1589700353608)(C:\Users\60917\AppData\Roaming\Typora\typora-user-images\1589453166432.png)]

  • 标签树的下行遍历
属性说明
.contents子节点的列表，将所有儿子节点存入列表
.children子节点的迭代类型，与.contents类似，用于循环遍历儿子节点
.descendants子孙节点的迭代类型，包含所有子孙节点，用于循环遍历

​ 遍历所有子孙节点

for child in soup.body.children:
    print(child)
#遍历所有的子节点
for child in soup.body.descendants:
    print(child)
#遍历所有的子孙节点
  • 标签树的上行遍历
属性说明
.parent节点的父亲标签
.parents节点先辈标签的迭代类型，用于循环遍历先辈节点
  • 标签树的平行遍历
    • 条件：平行遍历发生在同一个父节点下的各节点间。
属性说明
.next_sibling返回按照HTML文本顺序的下一个平行节点的标签
.previous_sibling返回按照HTML文本顺序的上一个平行节点的标签
.next_siblings迭代类型，返回按照HTML文本顺序的后续所有平行节点标签
.previous_siblings迭代类型，返回按照HTML文本顺序的前序所有平行节点标签

​ 标签树的平行遍历

for sibling in soup.a.next_siblings:
    print(sibling)
#遍历后续节点    
for sibling in soup.a.previous_sibliings:
    pring(sibling)
  • 小结：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bAXtGOgb-1589700353613)(C:\Users\60917\AppData\Roaming\Typora\typora-user-images\1589455735542.png)]

基于bs4库的HTML格式输出

  • 如何让内容更加“友好”的显示

    for bs4 import BeautifulSoup
soup = BeautifulSoup(demo,"html.parser")
soup.prettify()
#这样就可以变得友好

  • 编码：utf-8编码

Beautiful Soup库入门总结

  • bs4库的基本元素
    • Tag
    • Name
    • Attributes
    • NavigableString
    • Comment
  • bs4库的遍历功能
    • .contents：子节点（列表）
    • .children:循环遍历
    • .descendants：循环遍历
    • .parent
    • .parents
    • .next_sibling
    • .previous_sibling
    • .next_siblings
    • .previous_siblings

信息标记的三种形式

  • 信息标记：理解信息内容。

  • HTML的信息标记

    • HTML是WWW（World Wide Web）的信息组织方式

    • 将超文本信息嵌入到文本之中

    • HTML通过预定义的<>…</>标签形式组织不同类型的信息

  • 信息标记的三种形式

    • XML（扩展标记语言）

      • 标签Tag为主来表达信息
      • <>…</>和在中间没有内容的时候可以替换
      • 基于HTML的发展的一种通用的信息表达方式。

    • JSON：javaScript Object Notation

      • 有类型的键值对key：value
      • “key”:“value”
      • “key”：[“value1”,“value2”]
      • “key”:{“subkey”:“subvalue”}

    • YAML:YAML Ain’t Markup Language

      • 无类型的键值对

      • name：山东大学

      • name：（从属关系）

        ​ newname：山东大学

        ​ oldname：山东大学堂

      • name:（并列关系）

        ​ -山东大学

        ​ -山东大学堂

      • |表示整块数据 #表示注释

三种信息标记形式的比较

  • XML：一种用尖括号表达信息的方式

    • 实例：
    <person>
    <firestname>旋涡</firestname>
    <lastname>鸣人</lastname>
    <address>
        <streetAddr>某某街道某某号</streetAddr>
    	<city>火忍村</city>
        <zipcode>22222</zipcode>
    </address>
    <prof>忍者</prof><prof>火影</prof>
</person>

  • JSON：一种拥有类型键值对表达信息的方式

    • 实例
    {
    "firstname":"旋涡"
    "lastname":"鸣人"
    "address":{
				"streetAddr":"某某"
    			"city":"火忍村"
    			"zipcode":"22222"
				},
	"prof"	:	["忍者","火影"]
}

  • YAML：一种无类型的键值对表达信息的方式

    • 实例：
    firstname:旋涡
lastname鸣人
address:
	streetAddr:某某
	city:火忍村
	zipcode:22222
prof:
	-火影
	-忍者

  • 三种信息标记形式的比较

    • XML 最早的通用信息标记语言，可扩展性号，但是繁琐。
    • JSON 信息有类型，适合程序处理（JS），比XML简介
    • YANL信息无类型，文本信息比例最高，可读性好。
    • Internet上主要采用的是XML格式
    • JSON移动应用云端和节点的信息通信，（缺陷）无注释。（程序对接口处理的地方）
    • YAML 各类系统的配置文件，有注释易读

信息提取的一般方法

  • 方法一：完整解析信息的标记形式，再提取关键信息。

    • 用标记解析器解析XML、JSON、YAML格式，将其中所需要的信息提取出来。
    • 例如：bs4库的标签树遍历
    • 优点：信息解析准确
    • 缺点：提取过程繁琐，速度慢

  • 方法二：无视标记形式，所搜关键信息

    • 对信息的文本查找函数即可
    • 优点：提取过程简介，速度较快
    • 缺点：提取结果准确性与信息内容相关

  • 方法三：融合方法结合形式解析与搜索方法，提取关键信息

    • XML JSON YANL搜索
    • 需要表及解析器和文本查找函数

例子：

import requests
demo="网址"
r = requests.get(demo)
demo = r.text
soup = BeautifulSoup(demo,"html.parser")
for link in soup.find_all('a'):
    pring(link.get('href'))

基于bs4库的HTML内容查找方法

  • <>.fand_all(name,attrs,recursive,string,**kwargs)方法

    • 返回值类型是一个列表存储查找结果

    • name：对标签名称的检索字符串

      • soup.find_all([‘a’,‘b’])
      • soup.find_all(True) 显示所有标签信息
      • 需求：查找以b开头的标签
      import re
for tag in soup.find_all(re.compile('b')):
    print(tag.name)

    • attrs:对标签属性值得检索字符串，可标注属性检索

    • recursive:是否对子孙全部检索，默认True。

    • string:<>…</>中字符串区域的检索字符串

    • (…)等价于.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()参数

单元小结

  • 信息标记与提取方法
    • XML <>…</>
    • JSON 有类型key：value
    • YAML 无类型key：value
  • 信息提取的一般方法
  • 缩写形式

“中国大学排名定向爬虫”实例介绍

  • 思路：
    • 1.首先要获取页面信息
    • 2.然后找到自己需要的信息内容，把他放到一个数据结构中
    • 3.最后用数据结构将他们打印出来
import requests
from bs4 import BeautifulSoup
import bs4
def getHTMLText(url):
    try:
        r = requests.get(url)
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return " "
def fillUnivList(ulist,html):
    soup = BeautifulSoup(html , "html.parser")
    for tr in soup.find('tbody').children:
        if isinstance(tr , bs4.element.Tag):#作用是排除string中的tr
            tds = tr('td')    
            ulist.append([tds[0].string,tds[1].string,tds[4].string]) 

def printUnivList(ulist,num):
    tplt = "{0:^10}\t{1:{3}^10}\t{2:^10}"#用第三个来进行填充
    print(tplt.format("排名","学校名称","分数",chr(12288)))#chr（12288）中文空格
    for i in range(num):
        u = ulist[i]
        print(tplt.format(u[0],u[1],u[2],chr(12288)))
        
def main():
    uinfo = []
    url = "http://www.zuihaodaxue.com/zuihaodaxuepaiming2020.html"
    html = getHTMLText(url)
    fillUnivList(uinfo,html)
    printUnivList(uinfo,20)
    
main()

五、正则表达式

正则表达式的简介

正则表达式 regular expression regex RE

正则表达式是用来简洁表达一组字符串的表达式

  • 表达

’PN‘

’PYN‘ 正则表达式：

’PYTN‘ 等价于 P(Y|YT|YTH|YTHO)?N

‘PYTHN‘

’PYTHON‘

  • 表达无穷字符串组

‘PY’

‘PYY’ 等价于PY+

‘PYYY…’

  • ’PY‘开头

后续存在不多于10个字符

后续字符不能是’P‘或’Y‘ 等价于PY[^PY]{0，10}

  • 正则表达式

    • 通用的字符串表达框架
    • 简洁表达一组字符串的表达式
    • 针对字符串表达“简洁”和“特征”思想的工具
    • 判断某字符串的特征归属

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

    • 表达文本类型的特征（病毒、入侵）
    • 同时查找或替换一组字符串
    • 匹配字符串的全部或者部分（主要）

  • 正则表达式的使用

    • 编译：将符合正则表达是语法的字符串转换成正则表达式特征

正则表达式的语法

  • 正则表达式是由字符和操作符组成
操作符说明实例
.表示任何单字符
[]字符集，对单个字符给出取值范围[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_]
正则表达式对应字符串
P（Y|YT|YTH|YTHO）？N’PN‘、’PYN‘、’PYTN‘、‘PYTHN’、’PYTHON‘
PYTHON+’PYTHON‘、’PYTHON…‘
PY[TH]ON‘PYTON’、’PYHON‘
PY[’’^'TH]?ON(没有引号)’PYON‘、’PYaON‘…
PY{:3}N‘PN’、’PYYYN‘
  • 经典的正则表达式
正则表达式对应字符串
1+$由26个字母组成的字符串
2+$由26个字母和数字的字符串整数形式的字符串整数形式的字符串
^-?\d+$整数形式的字符串
3* [1-9]’’[0-9] *$(没有引号)正整数形式的字符串
[1-9]\d{5}中国境内邮政编码
[\u4e00-\u9fa5]匹配中文字符
\d{3}-\d{8}|\d{4}-\d{7}国内电话号码
  • 匹配IP地址的正则表达式

\d+.\d+.\d+.\d

\d{1:3}.\d{1:3}.\d{1:3}.\d{1:3}

精确版

(([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5]).){3}([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])

RE库的基本使用

  • Python的标准库，主要用于字符匹配

  • 调用方法 import re

  • 正则表达式的表示类型

    • raw string 类型（原生字符串类型）
      • r’text‘形式：r’[1-9]\d{5}‘
      • 不包含转义符的字符串
    • string类型，更繁琐
      • r’[1-9]\d{5}‘=’[1-9]\\d{5}’(两个斜杠)
函数说明
re.serach()在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象简单讲：就是搜索找到第一个一样的地方
re.match()从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall()搜索字符串，以列表类型返回全部能匹配的子串
re.split()将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer()搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub()在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
  • re.search(pattern,string,flags=0)
    • 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
      • pattern：正则表达式的字符串或原生字符串表示
      • string：待匹配字符串
      • flags：正则表达式使用时的控制标记
常用标记说明
re.I re.IGNORECASE忽略正则表达式的大小写，[A-Z]能够匹配小写字符
re.M re.MULTILINE正则表达式中的^操作符能够将给定字符串的每行当做匹配开始
re.S re.DOTALL正则表达式中的.操作符能够匹配所有字符，默认匹配除换行外的所有字符

  • re.match(pattern,string,flags=0)

    • 从一个字符串开始位置起匹配正则表达式，返回match对象。
      • pattern：正则表达式的字符串或原生字符串表示
      • string：待匹配字符串
      • flags：正则表达式使用时的控制标记

  • re.findall(pattern,string,flags=0)

    • 搜索字符串，以列表类型返回全部能匹配的子串。
      • pattern：正则表达式的字符串或原生字符串表示
      • string：待匹配字符串
      • flags：正则表达式使用时的控制标记

  • re.split(pattern,string,maxsplit=0,flags=0)

    • 将一个字符串按照正则表法师匹配结果进行分割，返回列表类型
      • pattern：正则表达式的字符串或原生字符串表示
      • string：待匹配字符串
      • maxsplit：最大分隔数，剩余元素作为最后一个元素输出
      • flags：正则表达式使用时的控制标记

  • re.finditer(pattern,string,flags=0)

    • 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
      • pattern：正则表达式的字符串或原生字符串表示
      • string：待匹配字符串
      • flags：正则表达式使用时的控制标记

  • re.sub(pattern,repl,string,count=0,flags=0)

    • 在一个字符串中替换搜有匹配正则表达式的子串，返回替换后的字符串。
      • pattern：正则表达式的字符串或原生字符串表示
      • repl:替换匹配字符串的字符串
      • string：待匹配字符串
      • count:最大替换次数
      • flags：正则表达式使用时的控制标记

  • regex = re.compile(pattern,falgs=0)

    • 将正则表达式的字符串形式编译成正则表达式对象。
      • pattern：正则表达式的字符串或原生字符串表示
      • flags：正则表达式使用时的控制标记

Re库的match对象

  • 一次匹配的结果，包含了很多匹配的相关信息。
  • match对象的属性
属性说明
.string待匹配的文本
.re匹配时的正则表达式
.pos正则表达式搜索文本的开始位置
.endpos正则表达式搜索文本的结束位置
  • match对象的方法
方法说明
.group(0)获得匹配后的字符串
.start()匹配字符串在原始字符串的开始位置
.end()匹配字符串在原始位置的结束位置
.span()返回（.start(),.end()）

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

match = re.search(r'PY.*N','PYASDASNSAN')
match.group(0)

返回结果？ Re库默认采用贪婪匹配的方式

  • 贪婪匹配

Re库默认采用贪婪匹配，即输出匹配最长的子串

最小匹配？怎么办？

match = re.search(r'PY.*?N','PYANASDAAN')
match.group(0)

这样的返回结果就是

’PYAN‘

操作符说明
*？前一个字符0次或无限次扩展，最小匹配
+？前一个字符1次或无限次扩展，最小匹配
？？前一个字符0次或1次扩展，最小匹配·
{m,n}？扩展前一个字符m至n（含n），最小匹配

单元小结

  • 正则表达式是用来简洁表达一组字符串的表达式

  • 正则表达式六个函数

实例淘宝商品比价定向爬虫

  • 目标：获取淘宝搜索页面的信息，提取其中商品的名称和价格
  • 理解：
    • 获得淘宝的搜索接口
    • 翻页的处理
import requests
import re

def getHTMLText(url):
    kv = {'cookie':'':'Mozilla/5,0'}
    #缺少cookie可以看我的另一篇博客
    try:
        r = requests.get(url,headers=kv,timeout=30)
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return ""

def parsePage(ilt,html):
    try:
        plt = re.findall(r'\"view_price\"\:\"[\d\.]*\"',html)
        tlt = re.findall(r'\"raw_title\"\:\".*?\"',html)
        for i in range(len(plt)):
            price = eval(plt[i].split(':')[1])
            title = eval(tlt[i].split(':')[1])
            ilt.append([price,title])
    except:
        print("")

def printGoodsList(ilt):
    tplt = "\t{:^4}{:^8}\t{:^16}" 
    count = 0
    print(tplt.format("序号",'价格','名称'))
    for i in ilt:
        count = count + 1
        print(tplt.format(count,i[0],i[1]))
        
def main():
    goods='书包'
    depth = 2
    infoilt = []
    start_url = 'https://s.taobao.com/search?q='+goods
    for i in range(depth):
        try:
            url = start_url + '&s=' + str(44*i)
            html = getHTMLText(url)
            parsePage(infoilt,html)
        except:
            continue
    printGoodsList(infoilt)
    
main()

实例股票数据定向爬虫

目的：获得上交所和深交所所有股票的名称和交易信息。

程序设计步骤

步骤一：从东方财富网获取股票列表

步骤二：根据股票列表逐个到百度股票获取个股信息

步骤三：将结果存储到文件

import requests
from bs4 import BeautifulSoup
import traceback
import re
def getHTMLText(url):
    try:
        r = requests.get(url,timeout=30)
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return ""
def getStockList(lst,stockURL):
    html = getHTMLText(stockURL)
    soup = BeautifulSoup(html,'html.parser')
    a = soup.find_all('a')
    for i in a:
        try:
            href = i.attrs['href']
            temp = re.findall(r'[1]\d{6}',href)[0]
            if temp not in lst:
                lst.append(temp)
        except:
            continue
    
        
def getStockInfo(lst,stockURL,fpath):
    for stock in lst:
        url = stockURL + stock +'.html'
        html = getHTMLText(url)
        try:
            if html =="":
                continue
            infoDict = {}
            soup = BeautifulSoup(html,'html.parser')
            stockInfo = soup.find('div',attrs={'class':'relate_stock clearfix'})

            info = stockInfo.find('script')
            str1 = info.string.replace(" ","")
            infolist = re.findall(r'.*\:\'.*\'',str1)
            for i in infolist:
                try:
                    key,value=str(i).split(':')
                    infoDict[key]=eval(value)
                except:
                    continue
            with open(fpath,'a',encoding='utf-8') as f:
                f.write(str(infoDict)+'\n')
            
        except:
            traceback.print_exc()
            continue

def main():
    stock_list_url = "http://quotes.money.163.com/data/caibao/yjyg_00.html"
    stock_info_url = "http://quotes.money.163.com/"
    output_file = 'D://gubiao.txt'
    slist = []
    getStockList(slist,stock_list_url)
    getStockInfo(slist,stock_info_url,output_file)
   
main()

实例优化

  • 已知网页编码
def getHTMLText(url,code='utf-8'):
    try:
        r = requests.get(url,timeout=30)
        r.encoding = code
        return r.text
    except:
        return ""

  1. A-Za-z ↩︎

  2. A-Za-z0-9 ↩︎

  3. 0-9 ↩︎

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值