本文章最初发布在 XJHui’s Blog,未经允许,任何人禁止转载!

注意:最新修改版本已发布在 这里,点击前往查看!

re模块

正则表达式

  1. 正则表达式:被用来检索(主要用途)、替换符合某个规则的字符
  2. re模块和正则的关系:先有正则后有re模块(C语言编写,速度快), re是python中用来实现正则功能的模块

mach()

匹配符合正则表达式规则的字符串 mach(pattern,data,flag=0)

  1. 案例(无标志位flag):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import re  # 导入re模块

    strData = 'hello world' # 字符串数据
    res = re.match('h', strData) # 两个参数分别代表:正则表达式、字符串数据
    if res:
    print('匹配成功')
    print(res.group()) # 使用res.group()返回匹配结果
    else:
    print('匹配失败')

    运行结果:

  2. 案例(有标志位flag):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import re

    strData = 'hello world'
    res = re.match('H', strData, re.I) # 第三个参数为标志位:re.I代表大小写不敏感
    if res:
    print('匹配成功')
    print(res.group()) # 如果匹配失败,使用res.group()则会报错
    else:
    print('匹配失败')

    运行结果:

    标志位可选参数:

  3. group():

    匹配结果会返回到group中

    • 下标:

      • group(0)(0可省略):匹配结果
      • group(1):返回第一组匹配结果
      • groups():返回所有组匹配结果
    • 案例:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      import re

      strData = 'Python is the best language in the world'
      res = re.match('(.*) is (.*?) .*', strData, re.I) # 第三个参数为标志位:re.I代表大小写不敏感
      if res:
      print('匹配成功')
      print('res.groups():', res.groups()) # groups(陪陪)
      print('res.group():', res.group())
      print('res.group(0):', res.group(0))
      print('res.group(1):', res.group(1))
      print('res.group(2):', res.group(2))
      else:
      print('匹配失败')

      运行结果:

    • 注意:

      • 有几组匹配结果的判断方法后面会讲解
      • group(0)、group()效果是一致的

        compile()

将正则表达式编译成一个正则表达式对象,以提高效率

  1. 为什么会提高效率?当使用match匹配时,python每次都会将正则表达式转换成对象,而使用compile只需要转换一次

  2. 案例:匹配4位数字

    • match方法:

      1
      2
      3
      4
      5
      6
      import re

      htmlTag = '12345677'
      pattern = '\d{4}' # 固定个数可使用{num}表示,下面具体会讲解
      res = re.match(pattern, htmlTag)
      print(res.group())

      运行结果:

    • compile方法:

      1
      2
      3
      4
      5
      import re

      reobj = re.compile('\d{4}')
      res = reobj.match('12345677')
      print(res.group())

      运行结果:

    • 注意:

      • 两种方法结果是一致的,只是速度有差别
      • 下文案例主要使用match方法讲解,但推荐使用compile方法

全文查找,找到一个就返回,而match必须是从开头开始匹配

1
2
3
4
5
6
7
import re

data = 'I love China!'
pattern = 'China'
res = re.search(pattern, data)
print(res)
print(res.group())

运行结果:

findall()

将所有匹配结果保存到列表中返回,而search只是返回第一个

1
2
3
4
5
6
import re

data = 'I love China, China!'
pattern = 'China'
res = re.findall(pattern, data)
print(res)

运行结果:

sub()

将匹配到的数据进行替换 re.sub(pattern,replace,data,count,flags=0)

1
2
3
4
5
6
import re

data = 'hello world'
pattern = 'l'
res = re.sub(pattern, 'L', data, 2) # 将匹配的字符换成L,并限制替换次数为2
print(res)

运行结果:

split()

分隔字符串(前面有讲过),最后返回一个列表

1
2
3
4
5
import re

data = '1,2,3,4,5,6'
res = re.split(',', data)
print(res)

运行结果:

常用匹配规则

匹配字符

  1. .(点)

    匹配任意1个字符(除了换行符\n)

    案例:匹配 ‘李娜’

    1
    2
    3
    4
    5
    6
    import re

    name = '李娜' # 数据
    pattern = '李.' # 正则表达式
    res = re.match(pattern, name) # match方法
    print(res.group())

    运行结果:

  2. []

    匹配括号中的任意一个字符

    1
    2
    3
    4
    5
    6
    import re

    name = 'elloh'
    pattern = '[he]'
    res = re.match(pattern, name)
    print(res.group(0))

    运行结果:

    注意:[a-z]、[A-Z]、[0-9]语法是正确的,甚至可以写成[a-zA-Z0-9]

  3. \d、\D

    匹配一个数字(0-9)、一个非数字

    • 案例1(\d,匹配一个数字):

      1
      2
      3
      4
      5
      import re

      data = '1123aaa'
      pattern = '\d'
      print(re.match(pattern, data).group())

      运行结果:

    • 案例2(\D,匹配一个非数字):

      1
      2
      3
      4
      5
      import re

      data = 'a1123a'
      pattern = '\D'
      print(re.match(pattern, data).group())

      运行结果:

  4. \s、\S

    匹配一个空字符、一个非空字符

    • \s(匹配一个空字符)

      1
      2
      3
      4
      5
      import re

      data = ' a1123a'
      pattern = '\s'
      print(re.match(pattern, data).group())
    • \S(匹配一个非空字符)

      1
      2
      3
      4
      5
      import re

      data = 'a1123a'
      pattern = '\S'
      print(re.match(pattern, data).group())
  5. \w、\W

    匹配一个单词字符(0-9、a-z、A-Z、_)、一个非单词字符

    • \w

      1
      2
      3
      4
      5
      import re

      data = 'a1123a'
      pattern = '\w'
      print(re.match(pattern, data).group())

      运行结果:

    • \W

      1
      2
      3
      4
      5
      import re

      data = ' a1123a'
      pattern = '\W' # 匹配一个空字符
      print(re.match(pattern, data).group())

匹配字符数量

匹配字符数量的符号满足前一个匹配规则的次数

  1. *

    满足前一个匹配规则0或无限次

    • 案例1:

      1
      2
      3
      import re

      print(re.match('[A-Z]*', 'MAAA').group())

      运行结果:

    • 综合案例:匹配符合规范的python变量名(不能以数字开头,只能包含字母和数字)

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      import re

      pattern = '[a-zA-Z_]+\w*' # 正则表达式(匹配字符要搭配一个数量),a-zA-Z0-9不需要加任何分隔符
      dataList = ['1nihao', 'nihao', 'Test111', 'Tes t_', 'Test_t', '**test'] # 测试数据
      for item in dataList:
      try: # 异常处理
      res = re.match(pattern, item)
      print(res.group())
      except AttributeError:
      pass

      运行结果:

  2. +

    满足前一个匹配规则至少1次

    1
    2
    3
    import re

    print(re.match('[a-bA-B]+', 'aabbcd').group()) # 注意:[a-b]表示[ab],其余同理

    运行结果:

  3. {,max}、{min,}、{min,max},?

    满足前一个匹配规则最多max次、最少min次、min-max次,0-1次

    • 案例:

      1
      2
      3
      4
      5
      import re

      print('\d{,5}', re.match('\d{,5}', '12344555a1').group())
      print('\d{1,}', re.match('\d{1,}', '12344555a1').group())
      print('\d{1,5}', re.match('\d{1,5}', '12344555a1').group())

      运行结果:

      注意:

      • ?的含义和{0,1}相同
      • 固定次数为5,可以使用{5}来实现
    • 综合案例:匹配qq邮箱(数字@qq.com)

      1
      2
      3
      4
      5
      6
      7
      8
      9
      pattern = '\d{1,}@qq.com'
      dataList = ['[email protected]', '[email protected]', '[email protected]', '[email protected]']
      for item in dataList:
      try:
      res = re.match(pattern, item)
      print(res.group())
      pass
      except AttributeError:
      pass

      运行结果:

原生字符串

python读取字符串时会对\后面的字符自动进行转义,从而引起一些问题

  1. 引入案例:打印路径 ‘d:\next\1day\4class’

    1
    2
    str = 'd:\python\next\1day\4class'
    print(str)

    运行结果:

    解决方法:在所有的\前面再添加一个转义字符\

    1
    2
    str = 'd:\\python\\next\\1day\\4class'
    print(str)

    运行结果:

  2. 匹配路径:’d:\\test’

    • 直接匹配:

      1
      2
      3
      import re

      print(re.match('d:\\test', 'd:\\test').group())

      运行结果:

      注意:在匹配时,正则表达式中会被转义成 ‘d:\test’ 故不能与 ‘d:\test’ 匹配成功

    • 解决方法1:

      1
      2
      3
      import re

      print(re.match('d:\\\\test', 'd:\\test').group())

      运行结果:

      注意:

      • 为什么要加两个\:因为匹配串中每个\都需要一个\去取消转义

      • 虽然上图结果是 ‘d:\test’ 但匹配成功的字符串肯定是 ‘d:\test’,因为只有 ‘d:\\test’ 打印出来才是 ‘d:\test’ :

    • 解决方法2:

      1
      2
      3
      import re

      print(re.match(r'd:\\test', 'd:\\test').group()) # 保证两个串中\个数一致,在正则前面加r

      运行结果:

      注意:如果你疑惑为什么少了个\,就去看解决方法1中的注2

匹配开头结尾

  1. ^

    匹配字符串的开头

    1
    2
    3
    import re

    print(re.match('^P.*', 'Python is good').group())

    运行结果:

  2. $

    匹配字符串的结尾

    1
    2
    3
    import re

    print(re.match('\d{1,13}@qq.com$', '[email protected]').group())

    运行结果:

分组匹配

  1. |

    匹配左右任意一个表达式

    1
    2
    3
    4
    5
    import re

    pattern = '[1-9]?\d$|100'
    print(re.match(pattern, '78').group())
    print(re.match(pattern, '100').group())

    运行结果:

    上面的正则表达式可分别匹配78、100,为便于理解,可将正则表达式分别如下:

  2. (ab)

    将括号中的字符作为一个分组

    1
    2
    3
    4
    5
    6
    7
    import re

    # 匹配电话号码 ****-12345678
    pattern = '(\d{4,4})-(\d{8,8})'
    print(re.match(pattern, '0101-12334234').group(0))
    print(re.match(pattern, '0101-12334234').group(1)) # 分组后的第一组
    print(re.match(pattern, '0101-12334234').group(2)) # 分组后的第二组

    运行结果:

    注意:每一个()对应一个匹配结果

  3. \num

    引用前面分组的字符串

    1
    2
    3
    4
    5
    6
    7
    htmlTag = '<html><h1>你好啊</h1></html>'
    pattern = r'<(.+)><(.+)>(.+)</\2></\1>' # /2、/1分别代表前面分组2(h1)和分组1(html),注意r可以加在''前面
    res = re.match(pattern, htmlTag)
    print(res.group(0))
    print(res.group(1))
    print(res.group(2))
    print(res.group(3))

    运行结果:

  4. ?P

    起别名:?P<名字> 使用别名:(?P=名字)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import re

    # 匹配html
    htmlTag = '<html><h1>你好啊</h1></html>'
    pattern = r'<(?P<html>.+)><(?P<h1>.+)>(.+)</(?P=h1)></(?P=html)>'
    res = re.match(pattern, htmlTag)
    print(res.group(0))
    print(res.group(1))
    print(res.group(2))
    print(res.group(3))

    运行结果:

贪婪模式

默认情况下会尽可能多的去匹配满足条件的数据

  1. 案例:

    1
    2
    3
    4
    5
    6
    7
    import re

    data = '123456'
    pattern = '\d{3,6}'
    pattern_no = '\d{3,6}?' # 非贪婪只需要在最后添加一个?
    print('贪婪:', re.match(pattern, data).group()) # 默认为贪婪模式
    print('非贪婪:', re.match(pattern_no, data).group())

    运行结果:

    注意:非贪婪模式会尽可能少的去匹配满足条件的数据,非贪婪模式中的?其实就是前面匹配字符数量中的?

  2. 优先级问题(极易错):

    1
    2
    3
    4
    content = 'aacbacbc'
    pattern = re.compile('a.*?b')
    result = re.search(pattern,content)
    print(result.group())

    运行结果:

    答案为什么不是acb? 因为最先开始的匹配拥有最高的优先权,即:

    匹配到的第一个a具有最高优先权,只要之后没有发生匹配失败的情况,它就会一直匹配下去,直到匹配成功,感谢 Siro阿希

后记

好啦,python基础的学习到这里就结束了!

后面会更新linux的学习笔记,期待吧!一起加油!

终于成功入门了一次,hahaha…


不足之处,欢迎留言,会及时回复,及时更正!

创作不易,感谢支持!