Python—正则表达式

宋正兵 on 2022-07-06

内置模块re的使用

re模块用于实现Python中的正则表达式的操作,为内置模块,不需要安装,导入即可使用。

常用的正则匹配方法:

  • re.match()方法:用于从字符串的开始位置进行匹配,如果匹配成功,结果为Match对象,否则结果为None。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #re.match(pattern, string, flags=0)
    import re
    pattern = r'\d\.\d+'
    s = 'I study Python3.10 every day'
    match = re.match(pattern, s, re.I)
    print(match) #None

    s2 = '3.10Python I study every day'
    match2 = re.match(pattern, s2, re.I)
    print(match2) #<re.Match object; span=(0, 4), match='3.10'>
    print('匹配值的起始位置:', match2.start()) #匹配值的起始位置: 0
    print('匹配值的结束位置:', match2.end()) #匹配值的结束位置: 4
    print('匹配区间的位置元组:', match2.span()) #匹配区间的位置元组: (0, 4)
    print('待匹配的字符串:', match2.string) #待匹配的字符串: 3.10Python I study every day
    print('匹配的数据:', match2.group()) #匹配的数据: 3.10
  • re.search()方法:用于在整个字符串中搜索第一个匹配的值,如果匹配成功则返回match对象,否则返回None。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #re.search(pattern, string, flags=0)
    import re
    pattern = r'\d\.\d+'
    s = 'I study Python3.10 every day, Python2.10 I love you'
    s2 = '4.10Python I study every day'
    s3 = 'I study Python every day'

    match = re.search(pattern, s)
    match2 = re.search(pattern, s2)
    match3 = re.search(pattern, s3)

    print(match) # <re.Match object; span=(14, 18), match='3.10'>
    print(match2) # <re.Match object; span=(0, 4), match='4.10'>
    print(match3) # None

    # 打印匹配的内容
    print(match.group()) # 3.10
    print(match2.group()) # 4.10
  • re.findall()方法:用于在整个字符串中搜索所有符合正则表达式的值,如果为一个列表

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #re.findall(pattern, string, flags=0)
    import re

    pattern = r'\d\.\d+'
    s = 'I study Python3.10 every day, Python2.10 I love you'
    s2 = '4.10Python I study every day'
    s3 = 'I study Python every day'

    lst = re.findall(pattern, s)
    lst2 = re.findall(pattern, s2)
    lst3 = re.findall(pattern, s3)

    print(lst) # ['3.10', '2.10']
    print(lst2) # ['4.10']
    print(lst3) # []

常用的正则处理方法

  • re.sub()方法:用于实现字符串的替换

    1
    2
    3
    4
    5
    6
    7
    #re.sub(patter, repl, string, count , flags=0)
    import re

    pattern = r'八嘎|西八'
    s = '西八!八嘎!get out!'
    new_s = re.sub(pattern, 'XXX', s)
    print(new_s) # XXX!XXX!get out!
  • re.split()方法:功能与字符串的split方法相同

    1
    2
    3
    4
    5
    #re.split(pattern, string, maxsplit, flags=0)
    pattern2 = r'[?|&]'
    s2 = 'https://www.google.com?username=abc&password=def'
    lst = re.split(pattern2, s2)
    print(lst) #['https://www.google.com', 'username=abc', 'password=def']

匹配单个字符与数字

.、[]、^、\d、\D、\w、\W、\s、\S

  1. .点:匹配除换行符以外的任意字符

  2. []:字符集合,匹配方括号中所包含的任意一个字符

    [0-9] 表示任意一个数字

    [abc] 表示匹配’a’、’b’、’c’中任意一个字符

    [a-z] 表示匹配任意一个小写字符

    [A-Z] 表示匹配任意一个大写字符

    [0-9a-zA-Z] 表示匹配任意一个数字和字母

    [0-9a-zA-Z_] 表示匹配任意一个数字、字母和下划线

  3. ^:与[]结合使用时为脱字符,表示不匹配集合中的字符。在其他位置意义不一样。

    [^abc] 表示匹配除了abc这几个字母以外的所有字符

    [^0-9] 表示匹配所有的非数字字符

  4. \d:匹配数字,效果同[0-9]

    [^\d] 表示匹配所有非数字字符,效果同[\^0-9]

  5. \D:匹配非数字字符,效果同[\^0-9]

  6. \w:匹配数字、字母和下划线,效果同[0-9a-zA-Z]

  7. \W:匹配非数字、字母和下划线,效果同[\^0-9a-zA-Z]

  8. \s:匹配任意的空白符(空格、换行、回车、换页、制表符),效果同[ \f\n\r\t](注意,\f前有一个空格)

  9. \S:匹配任意的非空白符(空格、换行、回车、换页、制表符),效果同[\^ \f\n\r\t](注意,\f前有一个空格)

匹配锚字符(边界字符)

^、$、\A、\Z、\b、\B

  1. ^:行首匹配,即必须要在开头,例如^test。^在[]内才表示不匹配集合中的字符

  2. $:行尾匹配,例如test$

  3. \A:匹配字符串开始。与^的区别在于:

    \A只匹配整个字符串的开头,^匹配的是每行的行首

  4. \Z:匹配字符串结束,与$的区别在于:

    \Z只匹配整个字符串的结束,$匹配的是每行的行尾

  5. \b:匹配一个单词的边界,也就是指单词和空格间的位置

  6. \B:匹配非单词的边界,也就是指单词和空格间的位置

1
2
3
4
5
print(re.findall(r'er\b', 'never'))  # ['er']
print(re.findall(r'er\B', 'never')) # []

print(re.findall(r'er\b', 'nerve')) # []
print(re.findall(r'er\B', 'nerve')) # ['er']

匹配多个字符

(xyz) 、x?、x、.、x+、x{n}、x{n,}、x{n,m}、x|y

  1. (xyz):匹配小括号内的内容,()内的内容xyz作为一个整体去匹配

  2. x?:匹配0个或者1个x,非贪婪匹配(尽可能少的匹配)

  3. x*:匹配0个或者任意多个x,贪婪匹配(尽可能多的匹配)

    .*:匹配0个或任意多个字符(换行符除外)

  4. x+:匹配至少一个x,贪婪匹配(尽可能多的匹配)

  5. x{n}:匹配确定的n个x,n是一个非负整数

  6. x{n,}:匹配至少n个x,n是一个非负整数

  7. x{n,m}:匹配至少n个最多m个x,n<=m

  8. x|y:|表示或,匹配的是x或者y

非贪婪匹配

*?、+?、??、{n,m}?

  1. *?:前一个字符0次或无限次匹配,最小匹配
  2. +?:前一个字符1次或无限次匹配,最小匹配
  3. ??:前一个字符0次或1次匹配,最小匹配
  4. {n,m}?:前一个字符n次到m次匹配,最小匹配

非贪婪我理解为如果可以是0次那么就0次,按最小的匹配来。