一、Requests库的7个主要方法

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

r = requests.get(url)

  • 返回一个包含服务器资源的Response对象，包含爬虫返回的全部内容(内容被封装，返回的是地址信息)
  • 构造一个向服务器请求资源的Request对象

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

  • url:拟获取网页的url链接
  • params:url中的额外参数，字典或字节流格式，可选
  • **kwargs:12个控制访问的参数
2.Response对象的属性
属性 说明
r.status_code HTTP请求的返回状态，200表示连接成功，404表示失败
r.text HTTP响应内容的字符串形式，即，url对应的页面内容
r.encoding 从HTTP header中猜测的响应内容编码方式
r.apparent_encoding 从内容中分析出的响应内容编码方式（备选编码方式）
r.content HTTP响应的二进制形式
  • r.encoding:如果header中不存在charset，则认为编码为ISO-8859-1
  • r.apparent_encoding:根据网页内容分析出的编码方式
3.理解Requests库的异常
异常 说明
requests.ConnectionError 网络连接错误异常，如DNS查询失败、拒绝连接等
requests.HTTPError HTTP错误异常
requests.TooManyRedirects 超过最大重定向次数，产生重定向异常
requests.ConnectTimeout 连接远程服务器时异常
requests.URLRequired URL缺失异常
Requests.Timeout 请求URL超时，产生超时异常
异常 说明
r.raise_for_status 如果不是200，产生异常requests.HTTPError
爬取网页的通用代码框架
1
2
3
4
5
6
7
8
9
10
11
12
13
import requests
def getHTMLText(url):
    try:
        r = requests.get(url,timeout=30)
        r.raise_for_status() # 如果状态不是200，引发HTTPError异常
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return '产生异常'

if __name__ == '__main__':
    url = 'http://www.baidu.com'
    print(getHTMLText(url))

二、HTTP协议

HTTP，Hypertext Transfer Protocol,超文本传输协议。

HTTP是一个基于”请求与响应“模式的、无状态的应用层协议。

  • 无状态：第一次请求与第二次请求无关联

HTTP协议采用URL作为定位网络资源的标识。

URL格式 http://host[:port][path]

  • host:合法的Internet主机域名或IP地址
  • port:端口号，缺省端口为80
  • path:请求资源的路径

HTTP URL的理解

URL是通过HTTP协议存取资源的Internet路径，一个URL对应一个数据资源。

1.HTTP协议对资源的操作
方法 说明
GET 请求获取URL位置的资源
HEAD 请求获取URL位置资源的响应消息报告，即获得该资源的头部信息
POST 请求向URL位置的资源后附新的数据
PUT 请求向URL位置存储一个资源，覆盖原URL
PATCH 请求局部更新URL位置的资源，即改变该处资源的部分内容
DELETE 请求删除URL位置存储的资源
2.理解PATCH和PUT的区别

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

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

  • 采用PATCH,仅向URL提交UserName的局部更新请求。
  • 采用PUT，必须将所有20个字段一并提交到URL，未提交字段被删除。

PATCH的最主要好处：节省网络带宽

三、Requests库的7个主要方法解析

1.requests.request()

requests.request(method,url,**kwargs)

method：请求方式。

‘GET’、’HEAD’、’POST’、’PUT’、’PATCH’、’delete’、’OPTIONS’

**kwargs:控制访问的参数，均为可选项。

  1. params:字典或字节序列，作为参数增加到url中。
  2. data：字典、字节序列对象，重点是向服务器提交资源时使用。
  3. json:JSON格式的数据，作为request的内容。
  4. headers:字典，HTTP定制头。
  5. cookies:字典或CookieJar,Request中的cookie。
  6. auth:元祖，支持HTTP认证功能。
  7. files:字典类型，传输文件。
  8. timeout:设定超时时间，秒为单位。
  9. proxies:字典类型，设定访问代理服务器，可以增加登录认证。
  10. allow_redirects:True/False,默认为True，重定向开关。
  11. stream:True/False,默认为True，获取内容立即下载开关。
  12. verify:True/False,默认为True，认证SSL证书开关。
  13. cert:本地SSL证书路径。

四、Beautiful Soup库使用

1.BeautifulSoup 基本使用
1
2
from bs4 import BeautifulSoup
soup = BeautifulSoup('<p>data</p>','html.parser') # 第一个参数为html文本内容，对html标签进行解析
2.Beautiful Soup库理解

Beautiful Soup库,也叫做 beautifulsoup4或bs4, 是解析、变量、维护”标签树“的功能库。只要提供的文件是标签类型，Beautiful Soup库都可以用来解析。

因为文档和标签树是一一对应的，标签树经过Beautiful Soup，转换为Beautiful Soup类型。故，文档和标签树以及Beautiful Soup是一一对应关系。

1
2
3
from bs4 import BeautifulSoup
soup = BeautifulSoup('<p>data</p>','html.parser')
soup2 = BeautifulSoup(open("D://demo.html",'html.parser')

Beautiful Soup对应一个HTML/XML文档的全部内容。

3.Beautiful Soup库解析器
解析器 使用方法 条件
bs的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,’htlm5lib’) pip install html5lib
4.Beautiful Soup类的基本元素
基本元素 说明
Tag 标签，最基本的信息组织单元，分别用<>和</>表面开头和结尾
Name 标签的名称，

…

的名字是’p’，格式：.name
Attributes 标签的属性，字典形式组织，格式：.attrs
NavigableString 标签内非属性字符串，<>…</>中字符串，格式：.string
Comment 标签内字符串的注释部分，一种特殊的Comment类型 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import requests
r = requests.get('http://python123.io/ws/demo.html')
demo = r.text # demo为标签文本
>
'<html><head><title>This is a python demo page</title></head>\r\n<body>\r\n<p class="title"><b>The demo python introduces several python courses.</b></p>\r\n<p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:\r\n<a href="http://www.icourse163.org/course/BIT-268001" class="py1" id="link1">Basic Python</a> and <a href="http://www.icourse163.org/course/BIT-1001870001" class="py2" id="link2">Advanced Python</a>.</p>\r\n</body></html>'

# 利用BeautifulSoup 解析成标签树
from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,'html.parser')
soup
>[out]:
<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.prettify())   # 输出标签树 
>[out]:
<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>

实例一 Tag

1
2
3
4
5
6
7
8
9
10
11
12
13
# 任何标签都可直接用soup.<标签>将其取出,当文本中存在多个相同标签时，其返回的为第一个

import requests
r = requests.get('http://python123.io/ws/demo.html')
demo = r.text # demo为标签文本

from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,'html.parser') # 解析的页面实例
soup.title # 标签
> <title>This is a python demo page</title>
tag = soup.a 
tag
> <a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>

实例二 Name

1
2
3
4
5
6
7
8
9
10
11
12
# 获取标签名称方法 <tag>.name
import requests
r = requests.get('http://python123.io/ws/demo.html')
demo = r.text # demo为标签文本

from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,'html.parser') # 解析的页面实例

soup.a.name
> 'a'
soup.a.parent.name # a的上一层标签,即父标签
> 'p'

实例三 Attributes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 获取标签的属性 <tag>.attrs
import requests
r = requests.get('http://python123.io/ws/demo.html')
demo = r.text # demo为标签文本

from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,'html.parser') # 解析的页面实例

tag = souo.a # 取a标签
attrs = soup.attrs # 提取出a标签的属性
> {'href': 'http://www.icourse163.org/course/BIT-268001',
 'class': ['py1'],
 'id': 'link1'}
# ，可以从结果看出，是字典的形式，故可直接通过键-值对的形式进一步提取信息内容
attrs['id']
> 'link1'
attrs['href']
> 'http://www.icourse163.org/course/BIT-268001'

实例四 NavigableString 

1
2
3
4
5
6
7
8
9
10
11
12
# 获取标签的属性 <tag>.string 用于取出标签之间的字符串
import requests
r = requests.get('http://python123.io/ws/demo.html')
demo = r.text # demo为标签文本

from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,'html.parser') # 解析的页面实例

soup.a.string
> 'Basic Python'
soup.p.string
> 'The demo python introduces several python courses.'   （可跨越标签层次）

实例五 判断注释

1
2
3
4
5
6
7
8
9
10
11
12
# 获取标签的属性 <tag>.string 用于取出标签之间的字符串
soup = BeautifulSoup("<b><! --This is a comment--></b><p>This is not a comment</p>",'html.parser')
soup.b.string
> 'This is not a comment'
type(soup.b.string)
> bs4.element.Comment
soup.p.string
> 'This is not a comment'
type(soup.p.string)
> bs4.element.NavigableString

# 两者的类型不同，来判断是否为注释
5.基于Beautiful Soup HTML的遍历方法

遍历方法：标签树，其为树形结构。

  • 下行遍历
  • 上行遍历
  • 平行遍历
5.1 下行遍历
属性 说明
.contents 子节点的列表，将所有儿子节点存入列表 （返回列表类型）
.children 子节点的迭代类型，与.contents类似，用于循环遍历儿子节点 （返回迭代类型）
.descendants 子孙节点的迭代类型，包含所有子孙节点，用于循环遍历 （同上）

本小结实例皆以代码作为开头，不再重复写 >代表输出

1
2
3
4
5
6
import requests
r = requests.get('http://python123.io/ws/demo.html')
demo = r.text # demo为标签文本

from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,'html.parser') # 解析的页面实例

实例一 .contents

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
soup.head.contents # 结果呈现出列表形式
>  [<title>This is a python demo page</title>]

soup.body.contents # 查看Body子节点的列表  
> 
['\n',
 <p class="title"><b>The demo python introduces several python courses.</b></p>,
 '\n',
 <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>,
 '\n']

len(soup.body.contents)
> 5

soup.body.contents[1] # 查看其下行节点的第二个
>  <p class="title"><b>The demo python introduces several python courses.</b></p>

标签树的下行遍历

  • 遍历儿子节点（只遍历一层）
1
2
for child in soup.body.children:
	print(child)
  • 遍历子孙节点（所有节点）
1
2
for child in soup.body.descendants:
	print(child)
5.2 标签树的上行遍历

基本代码：

1
2
3
4
5
6
7
8
9
10
11
soup = BeautifulSoup(demo,"html.parser")
for parent in soup.a.parents: # 对a标签所有的先辈名字进行打印
    if parent is None:
        print(parent)  # 不存在父亲节，则不打印名称
    else:
        print(parent.name) # 存在父亲节点，则打印出先辈节点名称
        
p
body
html
[document]
5.3 标签树的平行遍历
属性 说明
.next_sibling 返回按照HTML文本顺序的下一个平行节点标签
.previous_sibling 返回按照HTML文本顺序的上一个平行节点标签
.next_siblings 迭代类型，返回按照HTML文本顺序的后续所有平行节点标签
.previous_siblings 迭代类型，返回按照HTML文本顺序的前续所有平行节点标签

注意：平行遍历发生在同一个父节点下的各节点间**

实例一 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
soup.a.next_sibling 
> ' and '

soup.a.next_sibling.next_sibling   
> <a class="py2" href="http://www.icourse163.org/course/BIT-1001870001" id="link2">Advanced Python</a>

soup.a.previous_sibling 
> 'Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:\r\n'

soup.a.previous_sibling.previous_sibling  # 此时输出为空   
>

soup.a.parent.name 
> 'p'

标签树的平行遍历基本代码

  • 遍历后续节点
1
2
for sibling in soup.a.next_siblings:
    print(sibling)
  • 遍历前续节点
1
2
for sibling in soup.a.previous_siblings:
    print(sibling)
6.HTML的格式化输出
6.1 prettify()方法

soup.prettify() # 显示换行符

print(soup.prettify()) # 格式化输出，标签树形式

6.2 bs4库的编码
1
2
3
4
5
6
7
soup = BeautifulSoup('<p>中文</p>','html.parser')
soup.p.string
> '中文'
print(soup.prettify())
<p>
 中文
</p>

五、信息标记的三种形式

  1. XML

<name 属性 Attribute(包含标签 Tag)>...</name>

  1. **JSON**

有类型的键值对 key:value

1
2
3
4
5
6
7
8
 # 一键多值
"name":["value1","value2",...] 

# 键值对的嵌套使用
"name":{
    "key_1": "value1",
    "key_2": "value2"
}
  1. YAML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
name :
    newName : value
    oldName : value
    
# 表达并列关系
name :
	- value1
	- value2
# |表达整块数据，#表示注释
key : value
key: #Comment
- value1
- value2
key :
	subkey: subvalue
1.三种信息标记形式的比较
  • XML:Internet上的信息交互与传递。
  • JSON:移动应用云端和节点的信息通信，无注释。
  • YAML：各类系统的配置文件，有注释易读
2.信息提取的一般方法
  • 方法一：完整解析信息的标记形式，再提取关键信息。

XML JSON YAML

需要标记解析器 例如：bs4库的标签树遍历

优点：信息解析准确

缺点：提取过程繁琐，速度慢。

  • 方法二：无视标记形式，直接搜索关键信息。

搜索

对信息的文本查找函数即可

优点:提取过程简单，速度较快。

缺点：提取结果准确性与信息内容直接相关。

  • 融合方法

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

XML JSON YMAL 搜索

需要标记解析器及文本查找函数

实例

提取HTML中的所有URL链接

思路：

  1. 搜索到所有标签
  2. 解析标签格式，提取href后的链接内容
3.基于bs4库的HTML内容查找方法

前期工作

1
2
3
4
5
import requests
r = request.get('http://python123.io/ws/demo.html')
demo = r.text
from bs4 import BeautifulSoup
soup = BeautifulSoup(demo,'html.parser')

<>.find_all(name,attrs,recursive,string,**kwargs)

  • 返回一个列表类型，存储查找的结果。

name:对标签名称的检索字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
soup.find_all('a') # 返回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','b']) # 同时查询'a','b'标签，以列表形式返回
>Out[65]: 
[<b>The demo python introduces several python courses.</b>,
 <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>]

In [67]: for tag in soup.find_all(True): # 查询所有的标签
    ...:     print(tag.name) 
    ...:                                                                        
> 
html
head
title
body
p
b
p
a
a
  • attrs:对标签属性值的检索字符串，可标注属性检索。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
soup.find_all('p','course')   # 返回p标签中所有的course属性
Out[68]: 
[<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='link1')  # 返回id='link1'的全部标签信息
Out[71]: [<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>]

soup.find_all(id='link')  
Out[75]: []

# 查询带有link(查询出所有的link，无论尾号为几），需要借助正则表达式
import re
soup.find_all(id=re.compile('link'))  
Out[79]: 
[<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>]

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

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

1
2
3
4
5
6
7
8
9
# 只返回检索部分
soup.find_all(string='Basic Python')    
Out[80]: ['Basic Python']
    
# 利用正则表达式，提取全部
soup.find_all(string=re.compile('python')) # 提取全部带Python的过程
Out[82]: 
['This is a python demo page',
 'The demo python introduces several python courses.']

<tag>(...)等价于 <tag>.find_all()

soup(...)等价于soup.find_all(...)

4.扩展方法
方法 说明
<>.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()

六、正则表达式

1.正则表达式语法
1.1正则表达式由字符和操作符构成
操作符 说明 实例
. 表示任何单个字符
[] 字符集，对单个字符给出取值范围 [abc]表示a,b,c；[a-z]表示a到z单个字符
[^] 非字符集，对个单个字符给出排除范围 [^abc]表示非a或b或c的单个字符
* 前一个字符0次或无限次扩展 abc*表示ab、abc、abcc、abcc等
+ 前一个字符1次或无限次扩展 abc+表示abc、abcc、abccc等
？ 前一个字符0次或1次扩展 abc?表示ab、abc
| 左右表达式任意一个 abc|def表示adc、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’,’PYTHONN’,’PYTHONNN’…
PY[TH]ON ‘PYTON’,’PYHON’
PY[^TH]?ON ‘PYON’,’PYAON’,’PYBON’,…
PY{:3}N ‘PN’,’PYYN’,’PYYYN’
1.2经典正则表达式实例

^[A-Za-z]+$ 由26个字母组成的字符串

^[A-Za-z0-9]+$ 由26个字母和数字组成的字符串

^-?\d+$ 整数形式的字符串 - 表示负号

^[0-9]*[1-9][0-9]*$ 正整数形式的字符串

[1-9]\d{5} 中国境内邮政编码，6位

[\u4e00- \u9fa5] 匹配中文字符utf-8编码

\d{3}-\d{8}|\d{4}-\d{7} 国内电话号码，010-68913536

1.3匹配IP地址的正则表达式

IP地址字符串形式的正则表达式（IP地址分4段，每段0-255）

  • 粗略划分：

    • \d+.\d+.\d+.\d+
    • \d{1,3}.\d{1,3}.\d{1,3}.\{1,3}

  • 精确划分

    • 0-99: [1-9]?\d
    • 100-199:1\d{2}
    • 200-249:2[0-4]\d
    • 250-255:25[0-5]

    拼接：(([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])

2.Re库
2.1 raw string类型（原生字符串类型）

re库采用raw string类型表示正则表达式，表示为：r'text'

即：字符串原样输出，不用采用转移字符\。

2.2 Re库主要功能函数
函数 说明
re.search() 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match() 从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall() 搜索字符串，以列表类型返回全部能匹配的子串
re.split() 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer() 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub() 在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

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

    • 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象。

    • pattern:正则表达式的字符串或原生字符串表示

    • string:待匹配字符串。

    • flags:正则表达式使用时的控制标记。

      • flags:正则表达式使用时的控制标记

        常用标记 说明
        re.I re.IGNORECASE 忽略正则表达式的大小写，[A-Z]能够匹配小写字符
        re.M
        re.MULTILINE        		 正则表达式中的^操作符能够将给定字符串的每行当做匹配开始
        re.S
        re.DOTALL        		 正则表达式中的.操作符能够匹配所有字符，默认匹配除换行外的所有字符 
      1
      2
      3
      4
      5
      import re
      match = re.search(r'[1-9]\d{5}','BIT 100081')
      if match:
          print(match.group(0))
      > 100081

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

    1
    2
    3
    4
    import re
    match = re.match(r'[1-9]\d{5}','BIT 100081')
    match.group(0)
    > AttributeError: 'NoneType' object has no attribute 'group'

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

    1
    2
    3
    ls = re.findall(r'[1-9]\d{5}','AAA100081 BBBB100084')    
    ls
    >  ['100081', '100084']

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

    • maxsplit:最大分割数目，达到数目，剩余部分作为最后一个元素输出。
    1
    2
    re.split(r'[1-9]\d{5}','AAA100081 BBBB100084') # 将匹配的切割掉
    > ['AAA', ' BBBB', '']

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

    1
    2
    3
    4
    5
    6
    for m in re.finditer(r'[1-9]\d{5}','AAA100081 BBBB100084'): # 迭代输出
        if m:
            print(m.group(0))
    > 
    100081
    100084

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

    • repl:替换匹配字符串的字符串
    • count:匹配的最大替换次数
2.3 Re库的另一种等价用法

rst = re.search(r'[1-9]\d{5}','BIT 100081') 函数式用法：一次性操作

等价于：

1
2
3
# 面向对象用法：编译后的多次操作
pat = re.compile(r'[1-9]\d{5}') 
rst = pat.search('BIT 100081')

regex = re.compile(pattern,flags=0)

  • 将正则表达式的字符串形式编译成正则表达式对象
    • pattern:正则表达式的字符串或原生字符串表示
    • flags:正则表达式使用时的控制标记
2.4 Match对象的属性
属性 说明
.string 待匹配的文本
.re 匹配时使用的pattern对象（正则表达式）
.pos 正则表达式搜索文本的开始位置
.endpos 正则表达式搜索文本的结束位置
2.5 Match对象的方法
方法 说明
.group(0) 获取匹配后的字符串
.start() 匹配字符串在原始字符串的开始位置
.end() 匹配字符串在原始字符串的结束位置
.span() 返回(.start(),.end())
2.6 Re库的贪婪匹配和最小匹配

实例:

1
2
3
match = re.search(r'PY.*N','PYANBNCNDN')
match.group(0)
Out[101]: 'PYANBNCNDN'

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

最小匹配

1
2
3
match = re.search(r'PY.*?N','PYANBNCNDN')
match.group(0)
Out[102]: 'PYAN'

最小匹配操作符

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

未完待续….


博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：https://chemlez.github.io/2020/03/18/Python%E7%88%AC%E8%99%AB%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/

相关文章

Comment