python正则表达式基础

描述
正则表达式是用来简洁表达一组字符串的表达式
编译
将符合正则表达式语法的字符串转换成正则表达式特征
语法
正则表达式语法由字符和操作符构成
常用操作符：

操作符		说明							示例
.           表示任何单个字符  
[]          字符集，对单个字符给出取值范围    [ab]表示a、b，[a-z]表示a到z当字符
[^]         非字符集，对单个字符给出排除范围   [^ab]除了a、b之外任何单个字符
*           前一个字符0次或无限次扩展         ab*表示a、ab、abb等
+           前一个字符1次或无限次扩展
?           前一个字符0次或1次扩展
|           左右表达式任意一个              abc|bcd表示abc、bcd
{m}         扩展前一个字符m次               ab{2}c表示abbc
{m,n}       扩展前一个字符m至n次            ab{1,2}c表示 abc、abbc
^           匹配字符串开头                 ^ab表示匹配以ab开头的字符串
$           匹配字符串结尾
()          分组标记，内部只能使用|操作符   (abc)表示abc一个整体，(ab|cd)表示ab、cd
\d         数字，等价于[0-9]
\w         单词字符，等价于[A-Za-Z0-9]

正则表达式的表示类型
re库采用raw string（原生字符串类型）表示正则表达式，表示为：r’text’
例：

r'[1-9]\d{5}'
r'\d{3}-\d{8}|\d{4}-\d{7}'

Re库
Re库是python的标准库，主要用于字符串匹配
Re库主要功能函数：
re.search(pattern, string, flags=0)
在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
pattern：正则表达式
string：要匹配的字符串
flags：标志位，如：是否区分大小写、多行匹配等
标志位可选参数

import re
line="Cats are smarter than dogs"
s=re.search(r'(.*) are (.*?) .*',line)
print(s.groups()) # (.*)和(.*?) .*'
print(s.group()) # (.*) are (.*?) .*
print(s.group(1)) # (.*)
print(s.group(2)) # (.*?) .*

'''
结果：
('Cats', 'smarter')
Cats are smarter than dogs
Cats
smarter
'''

可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式

re.match(pattern, string, flags=0)
从一个字符串的开始位置起匹配正则表达式，返回match对象，如果不是起始位置匹配成功的话，match()就返回none。

import re
print(re.match('www', 'www.runoob.com'))  # 在起始位置开始匹配
print(re.match('com', 'www.runoob.com'))  # 不在起始位置开始匹配
'''
输出结果：
<re.Match object; span=(0, 3), match='www'>
None
'''

search()与match()的区别
match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而search 匹配整个字符串，直到找到一个匹配。
re.findall(string[, pos[, endpos]])
搜索字符串，以列表形式返回全部能匹配的子串
string 待匹配的字符串。
pos 可选参数，指定字符串的起始位置，默认为 0。
endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。

import re

pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)

print(result1)  # ['123', '456']
print(result2)  # ['88', '12']

re.split(pattern, string[, maxsplit=0, flags=0])
将一个字符串按照正则表达式匹配结果进行分隔，返回列表类型
maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

import re
string="1-2-3-4-5-6"
arr1=re.split(r'-',string)
arr2=string.split('-')
print(arr1,arr2)
# ['1', '2', '3', '4', '5', '6'] ['1', '2', '3', '4', '5', '6']

re.filter(pattern, string, flags=0)
搜索字符串，返回一个匹配结果的迭代类型，每个迭代原生都是

import re 
it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )   # 12 32 43 3 

re.sub(pattern, repl, string, count=0, flags=0)
在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
pattern：必需参数，正则表达式
repl : 必需参数，替换的字符串，也可为一个函数
string :必需参数， 要被查找替换的原始字符串。
count :可选参数， 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
flags : 可选参数，编译时用的匹配模式，数字形式。

import re

data = '2020-4-10 #这是一个日期'
# 删除注释
num = re.sub(r'#.*$', "", data)
print(num)            # 2020-4-10
# 移除非数字的内容
num = re.sub(r'\D', "", data)
print(num)     # 2020410

compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

re.compile(pattern[, flags])

import re
pattern = re.compile(r'\d+')         # 用于匹配至少一个数字
m = pattern.match('one12twothree34four')     # 查找头部，没有匹配
# 等价于m=re.match(r'\d+','one12twothree34four')
print( m )

re库的另一种用法
字符串.函数，例如字符串中的split()函数以上其它函数也可以使用

match对象属性
.string 待匹配的文本
.re 匹配时使用的正则表达式
.pos 正则表达式搜索文本的开始位置
.endpos 正则表达式搜索文本的结束位置

import re
m=re.search(r'\d+','one12twothree34four')
print("string:",m.string)
print("re:",m.re)
print("pos:",m.pos)
print("endpos:",m.endpos)

match对象的发方法
.group(0) 获取匹配后的字符串
.start() 匹配字符串在原始字符串的开始位置
.end() 匹配字符串在原始字符串的结束位置
.span() 返回**(.start(),.end())**

import re
s = "dafda12332afd12"
r = re.search(r'\d+', s)
print("group(0):", r.group(0))
print("start():", r.start())
print("end():", r.end())
print("span():", r.span())

'''
group(0): 12332
start(): 5
end(): 10
span(): (5, 10)
'''

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

import re
s = "pythonandjava"
print(re.search('py.*n', s).group(0))  # 结果是pythonan，而不是python

最小匹配操作符

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

示例

import re
s = "pythonandjava"
print(re.search('py.*?n', s).group(0))  # python