Re模块正则表达式

正则表达式常用符号：

【re中所有的flags解释】：如该格式中的flag：re.compile(pattern[, flag])

Re模块

》在python中，我们可以使用内置的re模块来使用正则表达式

》可以在sublime中,按ctrl+f,模拟正则表达式的写法

一、Re模块的使用步骤

使用compile函数将正则表达式的字符串形式编译为一个Pattern对象

通过Pattern对象提供的一系列方法对文本进行匹配查找，获得匹配结果(一个Matcch对象)

最后使用Match对象提供的属性和方法获得信息，根据需要进行其他的操作

二、原始字符串

注意：正则表达式使用\对特殊字符进行转义

只需要加一个r前缀，正则表达式可以写成：r'python\.org'来表示python.org

三、compile函数

compile函数用于编译正则表达式，生成一个Pattern对象

格式：re.compile(pattern[, flag])

pattern是一个字符串形式的正则表达式，flag是一个可选参数，表示匹配模式，比如忽略大小写，多行模式等。

四、match方法、search方法、findall方法、split方法和sub方法等的使用

1. match()方法

import re

# 将正则表达式编译成Pattern对象，用来匹配数字
pattern = re.compile(r"\d+")
print(pattern)  # 输出：re.compile('\\d+')

# match方法   从头部开始匹配
m1 = pattern.match("one12twothree34four")
print(m1)    # 输出：None 即没有匹配到数据

# 进行了指定起始位置和终止位置
m2 = pattern.match("one12twothree34four", 3, 10)
print(m2)   # 返回match对象 <re.Match object; span=(3, 5), match='12'>
# 使用group()查看数据
print(m2.group())   # 输出：12

'''
> match方法用于查找字符串的头部(也可以指定起始位置)，它是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果

> 格式：
  match(string[,pos[,endpos]])

> string是待匹配的字符串，pos和endpos是可选参数，指定字符串的起始和终点位置，默认值分别是0和len(字符串长度)。
  因此，当你不指定pos和endpos时，match方法默认匹配字符串的头部
  
> 当匹配成功时，返回一个Match对象，如果没有匹配上，则返回None
'''

2. search()方法

import re

# 将正则表达式编译成Pattern对象，用来匹配数字
pattern = re.compile(r"\d+")
print(pattern)  # 输出：re.compile('\\d+')

# search方法   从字符串任意位置开始匹配
m1 = pattern.search("one12twothree34four")
print(m1)   # 返回Match对象 <re.Match object; span=(3, 5), match='12'>
# 使用group()查看数据
print(m1.group())   # 输出：12

m2 = pattern.search("one12twothree34four", 5, 15)
# 使用group()查看数据
print(m2.group())   # 输出：34

'''
> search方法用于查找字符串的任何位置，它也是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果

> 格式：
  search(string[,pos[,endpos]])

> string是待匹配的字符串，pos和endpos是可选参数，指定字符串的起始和终点位置，默认值分别是0和len(字符串长度)。
  当匹配成功时，返回一个Match对象，如果没有匹配上，则返回None
'''

3. findall()方法

import re

# 将正则表达式编译成Pattern对象，用来匹配数字
pattern = re.compile(r"\d+")
print(pattern)  # 输出：re.compile('\\d+')

# findall方法     搜索全文，得到一个列表返回   如果没有匹配成功则返回一个空列表
result = pattern.findall("one12twothree34four")
# findall方法返回的是一个列表
print(result)   # 输出：['12', '34']

'''
> findall方法用于搜索整个字符串，获得所有匹配的结果

> 格式：
  findall(string[,pos[,endpos]])

> string是待匹配的字符串，pos和endpos是可选参数，指定字符串的起始和终点位置，默认值分别是0和len(字符串长度)。
  findall以列表的形式返回全部能匹配的子串，如果没有匹配，则返回一个空列表
'''

4. split()方法

# 回顾，在python中可以使用split()方法将字符串进行分割，返回的是一个列表
string = "a,b,c"
print(string.split(","))    # 输出：['a', 'b', 'c']

import re
# re中的split(分割)

str = "a,b;; c  d"

# 将正则表达式编译成Pattern对象，用来匹配 ,:和空格
pattern = re.compile(r"[,;\s]+")
# split方法返回的是一个列表
print(pattern.split(str))   # 输出：['a', 'b', 'c', 'd']

'''
> split方法按照能够匹配的子串将字符串分割后返回列表

> 格式：
  split(string[, maxsplit])
  
> maxsplit 用于指定最大分割次数，不指定将全部分割。
'''

5. sub()方法

import re
# re中的sub(替换)

string = '<h1 class="test">imooc</h1>'

# 将正则表达式编译成Pattern对象，用来匹配数字
pattern = re.compile("\d")

# ①当repl参数是字符串
# 调用re模块的sub方法，把h1标签里面的1换成了2
print(pattern.sub("2", string))  # 输出：<h2 class="test">imooc</h2>

# ①当repl参数是字符串，并携带count参数
# 调用re模块的sub方法，把h1标签里面的1换成了2，但只替换了1次，即最前面的那个
print(pattern.sub("2", string, 1))  # 输出：<h2 class="test">imooc</h1>


# 将正则表达式编译成Pattern对象，用来匹配上面的html标签
pattern1 = re.compile('<(.\d)\sclass="(.*?)">.*?</(.\d)>')

# ②当repl参数是函数
# 定义一个函数，match对象
def func(m):
    # 取了第二个分组
    return "after sub " + m.group(2)
# 调用sub方法
print(pattern1.sub(func, string))   # 输出：after sub test

'''
> sub方法用于替换

> 格式：
  sub(repl, string[, count])
    repl 可以是字符串也可以是一个函数
    count 用于指定最多替换次数，不指定时全部替换

> 如果repl是字符串，则会使用repl去替换字符串每一个匹配的子串，并返回替换后的字符串

> 如果repl是函数 ，这个方法应当只接受一个参数(Match对象)，并返回一个字符串用于替换
'''

五、分组

import re

# re中的分组
string = '<h1 class="test">imooc</h1>'

# 将正则表达式编译成Pattern对象，用来匹配上面的html标签
pattern1 = re.compile('<(.\d)\sclass="(.*?)">.*?</(.\d)>')
print(pattern1.search(string).group(1))  # 输出：h1

# 前面的.\d被后面的\1所引用，输出的内容一样
pattern2 = re.compile('<(.\d)\sclass="(.*?)">.*?</(\\1)>')
print(pattern2.search(string).group(3))  # 输出：h1

# 使用命名分组的方法，格式如:(?P<...>)
pattern3 = re.compile('<(.\d)\sclass="(?P<classname>.*?)">.*?</(\\1)>')
print(pattern3.search(string).group("classname"))   # 输出：test

六、贪婪与非贪婪

正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符

import re
# re模块的贪婪与非贪婪

string = '<h1 class="test">imooc</h1>'

# 使用了贪婪模式，匹配到所有的字符串
pattern1 = re.compile(r"<.\d\sclass=.*>")
print(pattern1.search(string).group())  # 输出：<h1 class="test">imooc</h1>

# 使用？关闭了贪婪模式
pattern2 = re.compile(r"<.\d\sclass=.*?>")
print(pattern2.search(string).group())  # 输出：<h1 class="test">


'''
贪婪模式
> 正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符
> 加上？就可以关闭贪婪模式了
'''