Day15-课堂笔记-正则表达式

1.正则表达式的符号

• 正则表达式：用来做字符串查找、匹配、切割用的工具
• python对正则表达式的支持：提供了re模块(python内置模块)包含字符串匹配、查找、切割等相关方法
• fullmatch(正则表达式，字符串)：用正在表达式来和字符串进行匹配，看是否能匹配成功
• 注意：正则表达式的字符串，前面要加r来阻止转义，因为正则表达式中有很多带''的符号，其功能表示特殊意义
• 正则表达式：是一个符合正则规范的字符串

1).:匹配一个任意字符

2)\w:匹配一个字符是字母、数字、或者是下划线

3)\s:匹配一个空白字符(空格、换行、制表符)

4)\d：匹配一个数字字符

5)\b:检测边界(单词边界--一般的符号都可以作为单词的边界)

6)^:匹配字符串的开头(^The--匹配一The开头的字符串)

7)$：匹配字符串结束

8)\W：匹配非字母、数字和下划线

9)\S：匹配非空白字符

10)\D：匹配非数字

11)\B：匹配非边界

# .:匹配一个任意字符
    re_str='.'*2#匹配两个字符
    # re_str='ab' #只能匹配第一个字符是a第二个是b的字符串
    re_str='a.'# 匹配第一个为a,第二个任意的字符串
    print(re.fullmatch(re_str, 'ab'))
    # 2. \w: 匹配一个字符是字母、数字、或者是下划线
    re_str=r'\w'*3
    print(re.fullmatch(re_str,'3e_'))
    #3.\s:匹配一个空白字符(空格、换行、制表符)
    # 1 a 2 空白 3 b的字符串
    re_str=r'a\sb'
    print(re.fullmatch(re_str,'a\tb'))
    # 4.\d：匹配一个数字字符
    re_str=r'\d'*3
    print(re.fullmatch(re_str,'102'))
    print(re.match(re_str, '1234'))
    # 5.\b:检测边界(字符串开头或者结束都是边界)
    re_str=r'\b...\b'
    print(re.match(re_str,'aaa\nssf'))
    #6. ^:检测字符串的开头( ^ The - -匹配一The开头的字符串)
    re_str=r'^The'
    print(re.fullmatch(re_str,'The'))
    # 7.$：检测字符串结束
    re_str=r'abc$'
    print(re.fullmatch(re_str,'abc'))
    print(re.findall(re_str, 'dfsd fds abc'))
    # 8.\W：匹配非字母、数字和下划线
    re_str=r'\W\w'
    print(re.fullmatch(re_str,'%s'))
    # 9.\S：匹配非空白字符
    re_str=r'\S\d'
    print(re.fullmatch(re_str,'d1'))
    # 10).\D：匹配非数字
    re_str=r'\D\d\s\S'
    print(re.fullmatch(re_str,'d1 f'))
    # 11.\B：匹配非边界
    re_str = r'abc\B'
    print(re.match(re_str, 'abcf'))
    re_str = r'abc\Bd'
    print(re.fullmatch(re_str, 'abcd'))
    re_str = r'\Babc\B'
    print(re.findall(re_str, 'dfsabcf'))

<re.Match object; span=(0, 2), match='ab'>
<re.Match object; span=(0, 3), match='3e_'>
<re.Match object; span=(0, 3), match='a\tb'>
<re.Match object; span=(0, 3), match='102'>
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 3), match='aaa'>
<re.Match object; span=(0, 3), match='The'>
<re.Match object; span=(0, 3), match='abc'>
['abc']
<re.Match object; span=(0, 2), match='%s'>
<re.Match object; span=(0, 2), match='d1'>
<re.Match object; span=(0, 4), match='d1 f'>
<re.Match object; span=(0, 3), match='abc'>
<re.Match object; span=(0, 4), match='abcd'>
['abc']

2.正则表达式符号

1）[]：匹配[]中出现的任意一个字符

[a-z]或[A-Z]:匹配a-z或A-Z中的任意一个字母字符
[a-zA-Z]:匹配所以字母

2)[^]:匹配不再[]中出现的任意一个字符

3)*:匹配0次或者多次

4)+:匹配一次或者多次

5)?:匹配零次或者一次

6){N}:匹配N次

7){M,}:匹配大于等于M次

8){M,N}:匹配最少M次最多N次

9)|：分支

10)()：匹配的时候是分组，让括号中的正则条件

变成一个整体
'''
''''================以下了解==============='''
'''
尽可能少：在能够匹配到的情况下尽可能少

11)*?：重复任意次，尽可能少的重复

12)+?:重复一次或者多次，尽可能少的重复

13)??：重复0次或者1次，尽可能少

14）{N,}?：重复至少N次，尽可能少

15）{N,M}?：重复N到M次，尽可能少

# 1.[]：匹配[]中出现的任意一个字符
    re_str=r'abc[a,]'
    print(re.fullmatch(re_str,'abca'))
    re_str=r'[\d_]abc'
    print(re.fullmatch(re_str,'_abc'))
    # 2.[ ^]:匹配不再[]中出现的任意一个字符
    # 匹配前三位是abc,第四位不是数字字符和a的字符串
    re_str=r'abc[^\da]'
    print(re.fullmatch(re_str,'abcf'))
    # 3.*:匹配0次或者多次
    # 匹配前面是0个或者多个数字字符，然后是数字、字符、下划线
    re_str=r'\d*\w'
    print(re.fullmatch(re_str,'35326j'))
    re_str=r'\d*:\d*.\d*'
    print(re.findall(re_str,'[00:00.00]'))
    # 4.+: 匹配一次或者多次
    re_str=r'\d+\w*'
    print(re.fullmatch(re_str, '3jdsfw3rsdf_'))
    # 5.?:匹配零次或者一次
    re_str=r'[a-z]?123'
    print(re.fullmatch(re_str,'123'))
    # 6.{N}:匹配N次
    re_str=r'\d{5}abc'
    print(re.fullmatch(re_str, '12345abc'))
    re_str=r'[12ab]{3}abd'
    print(re.fullmatch(re_str, '2ababd'))
    # 7.{M, }: 匹配大于等于M次
    re_str=r'\d{3,}.*'
    print(re.fullmatch(re_str,'233dfdgadg'))
    # 8.{M, N}: 匹配最少M次最多N次
    re_str=r'[\da-zA-Z]{8,16}'
    print(re.fullmatch(re_str, 'w2w3dfdgadg'))
# 9.|：分支
    # 匹配一个字符串，是三个数字字符串或者三个小写字母

    re_str=r'\d{3}|[a-z]{3}'
    print(re.fullmatch(re_str,'abc'))
    # 10.()：匹配的时候是分组，让括号中的正则条件
    # 变成一个整体
    # 匹配一个字符串，abc整体重复3次
    re_str=r'(abc){3}'
    print(re.fullmatch(re_str,'abcabcabc'))
    # 11.*?：重复任意次，尽可能少的重复
    re_str=r'ba*?b'
    print(re.match(re_str,'bbababaaaa'))
    # 12.+?:重复一次或者多次，尽可能少的重复
    re_str = r'ba+?b'
    print(re.match(re_str, 'baaababaaaa'))

<re.Match object; span=(0, 4), match='abca'>
<re.Match object; span=(0, 4), match='abc'>
<re.Match object; span=(0, 4), match='abcf'>
<re.Match object; span=(0, 6), match='35326j'>
['00:00.00']
<re.Match object; span=(0, 12), match='3jdsfw3rsdf'>
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 8), match='12345abc'>
<re.Match object; span=(0, 6), match='2ababd'>
<re.Match object; span=(0, 10), match='233dfdgadg'>
<re.Match object; span=(0, 11), match='w2w3dfdgadg'>

3正则表达式符号转义

1）特殊字符转义

正则中：.[]{}()*+?^|$,这些字符有特殊意义，所以在正则表达式中，如果想要单纯的表达这些字符，需要在前面加'',

• 注意：-，[]，^，\在中括号[]中可能有是特殊的符号，需要加\
  {}()*+?$|在中括号中可以不要加反斜杠\来表示字符

2)\N

匹配（复制）前面第N个组中匹配到的内容。组就是括号里面的内容

import re
if __name__ == '__main__':
    re_str=r'\d*[1\-3]\d*'
    print(re.fullmatch(re_str,'121-3'))
    re_str = r'[\^]'#匹配字符'^'
    print(re.fullmatch(re_str, '^'))
    re_str = r'[\\]'#匹配字符'\'
    print(re.fullmatch(re_str, '\\'))
    re_str = r'[\[]]'#匹配字符'[]'
    print(re.fullmatch(re_str, '[]'))
    re_str = r'[\[\]]'  # 匹配字符'[]'
    print(re.fullmatch(re_str, ']'))
    re_str = r'([1-9][a-z]{2})nn\1'
    print(re.fullmatch(re_str, '1aann1aa'))

4)re模块方法

• 1.compile(正则字符串)将正则表达式字符串转换成正则表达式对象
  转换成正则表达式对象后，可以通过对象调用相关的方法

• 2.fullmatch(正则表达式，字符串)完全匹配，从字符串开头匹配到结尾
  返回值是匹配对象,如果匹配失败返回None
  获取匹配结果：匹配对象.group()
  判断字符串是否是某种字符串(判断账号，密码是否符合要求等)

• 3.match(正则表达式，字符串)不完全匹配，从字符串的开头开始匹配，
  匹配到正则表达式对应的范围为止
  返回值是匹配对象,如果匹配失败返回None
  判断字符串是否以某种字符串开头

• 4.search(正则表达式，字符串)在指定的字符串中查找某种字符串(以正则表达式来描述)，
  只查找第一个
  返回值是匹配对象,如果匹配失败返回None
  判断一个字符串中是否包含某种字符串

• 5.finddall(正则表达式，字符串)去获取指定字符串中满足正则条件的
  所以字符串
  返回值是列表，列表中是符合要求的字符串。没有字符串满足就返回[]
  应用：字符串提取

• 6.finditer(正则表达式，字符串)用法和findall一样，只是返
  回值的类型不一样
  返回一个迭代器，迭代器中的内容是匹配对象
  注意：()捕获部分无效

• 注意：在通过正则表达式获取子串的时候，可以通过在正则表达式中添加括号，来约束获取的内容(只获取括号中匹配到的内容)
  匹配的时候还是按原正则表达式去查找

• 7.split(正则表达式，字符串)按正则表达式匹配到的字符串进行切割
  返回值是列表，列表元素是切割后被分段的字符串

• 8.sub(正则表达式，新字符串，原字符串)在原字符串中查找符合正则的子串，替换成新的字符串

import re
if __name__ == '__main__':
    # 1
    re_obct=re.compile(r'\w{6,12}')
    print(re_obct.fullmatch('abdfe34'))
    match=re.fullmatch('\w{3}','h3s')
    print(match)
    # 2
    # 获取匹配到的结果
    print(match.group())
    # 获取匹配到的范围
    print(match.span())
    # 获取匹配到的开始下标和结束下标
    print(match.start(),match.end())
    # 获取被匹配的字符串
    print(match.string)
    # 3
    match = re.match('\w{3}', 'h3sdfsf')
    print(match)
    print(match.group())
    # 获取匹配到的范围
    print(match.span())
    # 获取匹配到的开始下标和结束下标
    print(match.start(), match.end())
    # 获取被匹配的字符串
    print(match.string)

    # 5
    print(re.search(r'\d{2,}[a-z]','sha23n--877m0899'))
    result=re.findall(r'[a-zA-Z](\d+)','a123buye2360ks')
    print(result)
    #6
    result=re.finditer(r'[a-zA-Z](\d+)','sha23n--877m0899')
    for match in result:
        print(match)
    # 7
    result=re.split(r'[\[\]*\-]','a[fsdf3r]dfsa*df')
    print(result)
    # 8
    str1='你好sb,你全家都是sb'
    result=re.sub(r'sb','*',str1)
    print(str1,result)

<re.Match object; span=(0, 7), match='abdfe34'>
<re.Match object; span=(0, 3), match='h3s'>
h3s
(0, 3)
0 3
h3s
<re.Match object; span=(0, 3), match='h3s'>
h3s
(0, 3)
0 3
h3sdfsf
<re.Match object; span=(3, 6), match='23n'>
['123', '2360']
<re.Match object; span=(2, 5), match='a23'>
<re.Match object; span=(11, 16), match='m0899'>
['a', 'fsdf3r', 'dfsa', 'df']
你好sb,你全家都是sb 你好,你全家都是