re模块 正则表达式

在Python中的查找匹配方法。

1. re.match方法：(只从字符串开头匹配，返回的是一个 re.match 类型 <re.Match object; span=(0, 1), match=‘a’>的数据)
   从字符串的起始位置匹配，如果不是起始位置匹配成功的话，就返回none

   函数语法: re.match(pattern,string,flags=0) pattern，匹配的正则表达式；string，要匹配的字符串；flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

   使用group(num)函数来获取匹配到的元素
   例子：
   import re
   result1 = re.match(r’H’,‘Hello’)
   result2 = re.match(r’e’,‘Hello’)
   print(result1.group(0)) # ‘H’ 匹配到的元素
   print(result1.span()) # (0,1) 匹配到的元素所在位置
   print(result2) # None

re.fullmatch（pattern，string，flags = 0 ） 如果整个字符串与正则表达式模式匹配，则返回相应的match对象。 否则就返回一个 None ；注意这跟零长度匹配是不同的。

2. re.search方法：(扫描整个字符串，找到第一个匹配，返回的是一个 re.match 类型的数据)

   函数语法：re.search(pattern, string, flags=0)
   例子：
   import re
   result1 = re.search(r’He’,‘Hello’)
   result2 = re.search(r’lo’,‘Hello’)

print(result1.group(0)) # He
print(result1.span()) # (0,2)
print(result2.group(0)) # lo
print(result2.span()) # (3,5)

3. re.findall方法：(扫描整个字符串，找到所有的匹配，返回一个列表)
   在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表
   函数语法：re.findall(pattern,string,flags=0)
   例子：
   ret = re.findall(r’\d+’,‘he23ll34’)
   print(ret) # [‘23’, ‘34’]
   ret = re.match(r’\d+’,‘he23ll34’)
   print(ret) # None match只匹配开头，所以匹配到
   ret = re.search(r’\d+’,‘he23ll34’)
   print(ret) # <re.Match object; span=(2, 4), match=‘23’> search 只能匹配到一个数字

   注意事项:
   1） findall方法匹配时，如果匹配规则里有分组，则只匹配分组数据。
   ret = re.findall(r’\w+@(qq|126|163).com’,‘123@qq.com;aa@163.com;bb@126.com’)
   print(ret) # [‘qq’, ‘163’, ‘126’] 只匹配到了分组里的内容
   Copy
   2）如果正则表达式里存在多个分组，则会把多个分组匹配成元组。

ret = re.findall(r’\w+@(qq|126|163)(.com)’,‘123@qq.com;aa@163.com;bb@126.com’)
print(ret) #[(‘qq’, ‘.com’), (‘163’, ‘.com’), (‘126’, ‘.com’)]
Copy
3）如果想要让findall匹配所有的内容，而不仅仅只是匹配正则表达式里的分组，可以使用 ?:来将分组标记为非捕获分组。

ret = re.findall(r’\w+@(?:qq|126|163).com’,‘123@qq.com;aa@163.com;bb@126.com’)
print(ret) # [‘123@qq.com’, ‘aa@163.com’, ‘bb@126.com’]

4. re.finditer方法： (扫描整个字符串，找到所有的匹配，并返回一个迭代器，迭代器里的每一个元素是一个 re.Match 对象)
   例子：
   ret = re.finditer(r’\d+’,‘he23ll34’) # 得到的结果是一个迭代器
   for x in ret: # 遍历 ret 取出里面的每一项匹配
   print(x.group(), x.span()) # 匹配对象里的group保存了匹配的结果

5. re.sub(pattern, repl, string, count=0, flags=0) 用repl(可以是字符串或函数)替换匹配到的内容，并返回替换后的整个字符串；count 指替换的次数，默认0 全部替换。
   例子：print(re.sub(r’\d’, ‘-’, ‘he11o’, count=1)) # he-1o
   def test(match):
   #print(‘接收到的参数x = {}’.format(match))
   #test函数会自动被调用，并且会将匹配到的 re.Match对象传递过来
   return str(int(match.group(0)) * 2)
   print(re.sub(r’(?P\d+)’, test, ‘dsf29adf’)) # ‘dsf58adf’

6. re.subn(pattern, repl, string, count=0, flags=0) 行为与 sub() 相同，但是返回一个元组 (字符串, 替换次数)

7. re.purge() 清除正则表达式缓存

8.re.compile(pattern, flags=0) 我们在使用正则表达式时，可以直接调用re 模块的 match,search,findall等方法，传入指定的正则表达式。同时，也可以调用re.compile方法，生成一个正则表达式对象，再调用这个正则表达式对象的相关方法（search，match，fullmatch，split，findall，finditer，sub，subn等）实现匹配。如果需要多次使用这个正则表达式的话，使用 re.compile() 保存这个正则对象以便复用，可以让程序更加高效。

re.Match类的属性和方法：

当我们调用re.match方法、re.search方法，或者对re.finditer方法的结果进行迭代时，拿到的数据类型都是re.Match对象。

b = re.search(r’(x\d+y)(?P.?)(\dp)’, ‘dfax8329ydksfm238p’)
#group(index) 通过下标来获取对应分组匹配到的字符串
print(b.group()) # x8329ydksfm238p,如果不传入下标，表示第 0 个分组，就是整个正则表达式的结果
print(b.group(0)) # x8329ydksfm238p,整个整个正则表达式的结果
print(b.group(1)) # x8329y，第 1 个分组的匹配结果
print(b.group(2)) # dksfm
print(b.group(3)) # 238p
print(b.group(‘test’)) # dksfm 除了使用下标以外，还可以使用分组名获取匹配结果

print(b.groups()) # (‘x8329y’, ‘dksfm’, ‘238p’),获取所有分组的匹配结果，组成一个元组返回

print(b.groupdict()) #{‘test’: ‘dksfm’},返回组名作为key，分组的匹配结果作为value的字典
print(b.groupdict(‘test’)) # {‘test’: ‘dksfm’}

#span 可以传入group的参数来获取，匹配到结果的开始和结束下标
print(b.span()) # (3, 18),左闭右开
print(b.span(1)) # (3, 9)

print(b.start(2)) # 9 该分组从哪个下标开始，包含这个下标
print(b.end(1)) # 9 该分组到哪个下标结束，不包含这个下标

print(b.re) # re.compile(’(x\d+y)(?P.?)(\dp)’)，返回当前使用的正则表达式
print(b.string) # dfax8329ydksfm238p，返回被搜索的字符串

print(b.pos) # 0,搜索的开始位置下标
print(b.endpos) # 18,搜索的结束位置下标
print(b.lastindex) # 3,最后匹配的组的索引
print(b.lastgroup) # None,最后匹配的组的组名
print(b.expand(r’第一个组的结果是\1’)) # 第一个组的结果是x8329y,该方法利用一个类似sub方式，将字符串中指定的利用反斜杠标示的数字或组名替换为相应组中值，然后返回整个字符串

正则模式的基本规则：
正则模式就是正则匹配规则，也就是正则表达式字符串。
1. 字母和数字表示他们自身，一个正则表达式模式中的字母和数字匹配同样的字符串。
2. 多数字母和数字前加一个反斜杠 \ 时会拥有不同的含义。
3. 绝大多数标点符号都有特殊含义.如果要表示符号本身，需要使用 \ 转义。
4. 斜杠本身需要使用反斜杠转义；最好使用原始字符串来表示它们。模式元素(如 r’\t’，等价于\t )匹配相应的特殊字符

正则表达式字符：
1. 非打印字符：
\n 匹配一个换行符。等价于 \x0a 和 \cJ
\r 匹配一个回车符。等价于 \x0d 和 \cM
\f 匹配一个换页符。等价于 \x0c 和 \cL
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]
\t 匹配一个制表符。等价于 \x09 和 \cI
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK
2. 特殊字符
\d 匹配一个数字字符。等价于 [0-9]
\D 匹配一个非数字字符。等价于 [^0-9]
\w 匹配大小写字母，数字和下划线 _ 。等价于[A-Za-z0-9_]
\W 匹配非字母或数字或下划线。等价于 [^A-Za-z0-9_]。
( ) 用来进行分组，标记一个子表达式的开始和结束位置。要匹配这些字符，请使用 ( 和 )。
. 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 .
[] 用来表示可选范围
| 指明两项之间的一个选择，或。要匹配 |，请使用 |
{m} 限定前面字符重复出现 m 次
{m,} 限定前面字符重复m次或更多次
{,m} 限定前面字符最多出现 m 次
{n,m} 限定前面字符重复n到m次
[\u4e00-\u9fa5] 匹配纯中文
? 表示字符最多出现一次 等价于 {,1}
* 表示字符出现任意次数 等价于 {0,}
+ 表示字符出现一次以上 等价于 {1,}
^ 匹配字符串的开始；在中括号中时，它表示不接受该字符集合，例如[^0-9]匹配除了数字以外的数据。要匹配 ^ 字符本身，请使用 ^
$ 匹配字符串的结尾
3. 正则表达式修饰符：
re.I(re.IGNORECASE) 忽略大小写匹配
print(re.search(r’E’, ‘hello’, re.I))
re.M(re.MULTILINE) 多行匹配，影响 ^ 和 $
print(re.findall(r’^\d.*\d$’, ‘4hello5\n6good7\n8yes9’, re.M))
re.S(re.DOTALL) 使 . 匹配包括换行在内的所有字符
print(re.search(r’.’, ‘\n’, re.S))

贪婪模式和非贪婪模式：
在正则表达式里，默认匹配时是贪婪的，都是尽可能多的匹配。
match1 = re.search(r’(.+)(\d{3,})(.)’, ‘hello123456good’)
print(match1.group()) # hello123456good
print(match1.group(1)) # hello123
print(match1.group(2)) # 456
在,?,+,{m,n}后面加上 ?使贪婪变成非贪婪。
match2 = re.search(r’(.+?)(\d{3,})(.*)’, ‘hello123456good’)
print(match2.group(1)) # hello
print(match2.group(2)) # 123456

url = ‘’
match5 = re.search(r’https://.*?.jpg’, url)
print(match5.group())