import re
'''
. 匹配任意字符
[] 匹配[]出现的内容
[^...] 匹配不在[]出现的内容
\d 匹配数字
\D 匹配非数字
\s 匹配空白
\S 匹配非空白
\w 匹配字母，数字，下划线，汉字
\W 匹配非字母，非数字，非下划线，非汉字
^ 匹配行首
$ 匹配行尾
\A 匹配字符串的开头
\z 匹配字符串的结尾
\Z 字符串结束，有换行，则换行前结束
\b 匹配单词边界
\B 匹配非单词边界
\G 最后匹配完成的位置
a|b 匹配a或b
{n} 匹配n次
{n,} 匹配大于等于n次
{n, m} 匹配n到m次，包括n和m
* 匹配0次或多次
+ 匹配1次或多次
? 匹配0次或一次
*? 匹配0次或多次，越少越少
+? 匹配1次或多次，越少越好
?? 匹配0次或1次，越少越好
[0-9] 匹配0-9中的任意一个数字
[a-z] 匹配a-z中的任意一个字母
[A-Z] 匹配A-Z中的任意一个字母
备注：对于Python来说，默认是贪婪匹配，一个正则表达式做最大程度的匹配
'''
'''
re.match(pattern, string, flags=0)
尝试从字符串的开始位置来匹配正则表达式，如果从开始位置匹配不成功，match() 函数就返回 None 。其中 pattern 参数代表正则表达式；
string 代表被匹配的字符串；flags 则代表正则表达式的匹配旗标。该函数返回 _sre.SRE_Match 对象，该对象包含的 span(n)
方法用于获取第 n+1 个组的匹配位置，group(n) 方法用于获取第 n+1 个组所匹配的子串。
match方法可以指定匹配的开始下标和结束下标
'''
test_str = 'hfhewkfsklsgjgegje'
pattern = re.compile('hfhe')
pattern1 = re.compile('fskl')
result = pattern.match(test_str)
print(pattern1.match(test_str, 6))
print(pattern1.match(test_str, 6, 10))
print(result.span()) # 获取匹配下标范围
print(result.group()) # 获取匹配结果
print(result.start()) # 获取匹配起始下标
print(result.end()) # 获取匹配结束下标
print(result.string) # 获取被匹配的字符串
'''
re.search(pattern, string, flags=0)
扫描整个字符串，并返回字符串中第一处匹配 pattern 的匹配对象。其中 pattern 参数代表正则表达式；string 代表被匹配的字符串；
flags 则代表正则表达式的匹配旗标。该函数也返回 _sre.SRE_Match 对象。
match() 与 search() 的区别在于，match() 必须从字符串开始处就匹配，但 search() 可以搜索整个字符串
'''
test_str = 'hfhewkfsklsgjgegje'
pattern = re.compile('fskl')
result1 = pattern.search(test_str)
print(result1.group())
'''
re.findall(pattern, string, flags=0)
扫描整个字符串，并返回字符串中所有匹配 pattern 的子串组成的列表。其中 pattern 参数代表正则表达式；string 代表被匹配的宇符串；
flags 则代表正则表达式的匹配旗标。
'''
test_str = 'abcddfjsabcdfhewhfabcd'
pattern = re.compile('abcd')
result2 = pattern.findall(test_str)
print(result2) # ['abcd', 'abcd', 'abcd']
'''
re.finditer(pattern, string, flags=0)
扫描整个字符串，并返回字符串中所有匹配 pattern 的子串组成的迭代器，迭代器的元素是 _sre.SRE_Match 对象。
其中 pattern 参数代表正则表达式；string 代表被匹配的字符串；flags 则代表正则表达式的匹配旗标。
'''
test_str = 'abcddfjsabcdfhewhfabcd'
pattern = re.compile('abcd')
result2 = pattern.finditer(test_str)
for i in result2:
print(i.group())
print(i.span())
# abcd
# (0, 4)
# abcd
# (8, 12)
# abcd
# (18, 22)
'''
re.fullmatch(pattem, string, flags=0)
该函数要求整个字符串能匹配 pattern，如果匹配则返回包含匹配信息的 _sre.SRE_Match 对象；否则返回 None。
fullmatch可以指定匹配的开始下标和结束下标
'''
test_str = 'hfsehfe'
pattern = re.compile('hfsehfe')
result = pattern.fullmatch(test_str)
print(result.group()) # hfsehfe
print(result.span()) # (0, 7)
'''
re.sub(pattern, repl, string, count=0, flags=0)
该函数用于将 string 字符串中所有匹配 pattern 的内容替换成 repl；repl 既可是被替换的字符串，也可是一个函数。
count 参数控制最多替换多少次，如果指定 count 为 0 ，则表示全部首换。默认为为0
'''
test_str = '2020-3-31'
patter = re.compile('-')
print(patter.sub('/', test_str)) # 2020/3/31
'''
re.split(pattem, string, maxsplit=0, flags=0)
使用 pattern 对 string 进行分割，该函数返回分割得到的多个子串组成的列表。其中 maxsplit 参数控制最多分割几次。
默认为0，表示全部分割
'''
test_str = '20,20-3-31'
pattern = re.compile('-|,')
print(pattern.split(test_str))
def fun(matched):
# matched就是匹配对象，通过该对象的group()方法可获取被匹配的字符串
value = "《基础" + (matched.group('lang')) + "教程》"
return value
s = 'Python很好，Kotlin也很好'
# 将s里面的英文单词（用re.A旗标控制）进行替换
# 使用fun函数指定替换的内容
print(re.sub(r'(?P<lang>\w+)', fun, s, flags=re.A)) # 命名捕获组
'''
re.purge()：清除正则表达式缓存。
'''
'''
re.escape()
对模式中除 ASCII 字符、数值、下画线（_）之外的其他字符进行转义
该方法有利于我们写正则表达式
'''
test_str = 'http://python.org'
tran_pattern = re.escape(test_str) # http://python\.org
pattern = re.compile(tran_pattern)
print(pattern.fullmatch(test_str))
'''
捕获组
在正则中使用()，就表示使用了捕获组
命名捕获组
(?P<name>pattern)
'''
test_str ='python java golang php ruby erlang'
pattern = re.compile('(python).*?(golang).*?')
result = pattern.search(test_str)
print(result) #<re.Match object; span=(0, 18), match='python java golang'>
print(result.group()) # 获取所有的内容 python java golang
print(result.group(0)) # 获取所有的内容 python java golang
print(result.group(1)) # 获取编号为1号的捕获组的内容 python
print(result.group(2)) # 获取编号为2号的捕获组的内容 golang
print(result.groups()) # 获取所有的捕获组的内容 ('python', 'golang')
test_str = 'http://python.org is a domain'
pattern = re.compile('(?P<prefix>python).*?(?P<suffix>org).*?')
result = pattern.search(test_str)
print(result.group()) # python.org
print(result.groups()) # ('python', 'org')
print(result.groupdict()) # {'prefix': 'python', 'suffix': 'org'}
'''
正则表达式的标志位:
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定
re.I 忽略大小写
re.M 多行匹配，影响^和$
re.S 使.能够匹配包括换行符在内的所有内容
re.X 忽略空格和 # 后面的注释
re.U Unicode解码，影响 \w, \W, \b, \B, \d, \D, \s, \S 如果设置了此re.UNICODE标志，就会影响到\w,\W,\b,\B,\d,\D,\s,\S的含义。
re.L 本地化识别匹配，影响 \w, \W, \b, \B, \d, \D, \s, \S 如果添加了re.LOCALE这个标志，则：\w,\W,\b,\B,\s,\S的含义，和具体的locale相关。
'''
test_str = 'PYTHON is good!'
pattern = re.compile('python is good!', re.I)
print(pattern.fullmatch(test_str)) # <re.Match object; span=(0, 15), match='PYTHON is good!'>
test_str = '''Million nothing green human.
Mission finally discover other social cut
century. Provide argue political study while improve view.'''
pattern1 = re.compile('.*?(human).*?(study).*?', re.S)
print(pattern1.fullmatch(test_str))
test_str = 'python\ngo\njava'
pattern = re.compile('^\w+')
pattern1 = re.compile('^\w+', re.M)
print(pattern.findall(test_str)) # ['python']
print(pattern1.findall(test_str)) # ['python', 'go', 'java']
'''
零宽断言：用于查找特定内容之前或之后的内容，但并不包括特定内容本身。
对于零宽断言来说，最重要的一个概念是位置，零宽断言用于指定一个位置，这个位置应该满足一定的条件(它附近满足什么表达式)，
并且这个位置不是字符（因此匹配返回无结果），仅仅是一个位置，因此它们也被称为零宽断言
零宽断言重点的这一个位置，是通过一个条件：这个位置附近（前或者后）存在或者不存在一个A（A可以是一个表达式）来决定的
(?=exp) ：此位置后面匹配表达式exp 正向前视断言
(?!exp)：此位置后面不匹配表达式exp 负向前视断言
(?<=exp)：此位置前面匹配表达式exp 正向后视断言
(?<!exp)：此位置前面不匹配表达式exp 负向后视断言
正向，负向表示匹配不匹配的关系
前视，后视指定了是表示之前，还是表达式之后，前视表示表达式后面的位置，后视表示表达式前面的位置。将正则匹配
看做是对字段字符串的扫描，已经扫描的表示后面，所以称为后视，还没扫描的看做前面，所以叫做前视
'''
str = '<div>hello world</div>'
print(re.search('(?=he).*', str).group()) # hello world</div>
print(re.search('(?!he).*(?<=ld)', str).group()) # <div>hello world
网友评论