python基础模块---re

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\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))

'''
捕获组
    在正则中使用()，就表示使用了捕获组
命名捕获组
    (?Ppattern)
'''
test_str ='python java golang php ruby erlang'
pattern = re.compile('(python).*?(golang).*?')
result = pattern.search(test_str)
print(result)       #
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('(?Ppython).*?(?Porg).*?')
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))      # 


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      正向后视断言   
    (?hello world

' print(re.search('(?=he).*', str).group()) # hello world

print(re.search('(?!he).*(?<=ld)', str).group()) #

hello world