• re库


    一、Re库的主要功能:

    函数 功能
    re.search() 在一个字符串中搜索匹配正则表达式的第一个位置,返回match对象
    re.match() 在一个字符串的开始位置匹配正则表达式,返回match对象
    re.findall() 搜索字符串,以列表的形式返回全部能匹配的子串
    re.split() 将一个字符串按照正则表达式匹配的结果进行分割,返回列表类型
    re.finditer() 搜索字符串,返回一个匹配的迭代类型,每个迭代元素是match对象
    re.sub() 在一个字符串中替换所有匹配正则表达式的子串,返回替换后的字符串

    二、Re库的主要函数的功能:

    •re.search(pattern,string,flags=0)

    参数 功能
    pattern 正则表达式的字符串或原生字符串表示
    string 带匹配的字符串
    flags 正则表达式使用时的控制标记

    (1)flags的常用标记:

    常用标记 说明
    re.I   re.IGNORECASE 忽略正则表达式的大小写,[A-Z]能够匹配小写字符
    re.M  re.MULTLINE 正则表达式中的^操作符能够将给定字符串的每行当做匹配开始
    re.S  re.DOTALL 正则表达式中的.操作符能够匹配所有字符,默认匹配除 外的所有字符

    (2)search函数实例

    1 import re
    2 match1 = re.search(r'[1-9]d{5}','BIT 100081 TSU100084')
    3 if match1:
    4     print(match1.group(0))
    5 
    6 #结果:100081

    •re.match(pattern,string,flags=0)

    (1)match函数实例

    1 import re
    2 match2 = re.match(r'[1-9]d{5}','BIT 100081')
    3 if match2:
    4     print(match2.group(0))
    5     
    6 #print(match2.group(0)),注意,如果这里不直接判断re.match()返回的对象是否为空,会报错,
    7 #因为这里的match2并没有从这个字符串的开始部分匹配到目标字符串,所以返回的match2对象没有group这个参数
    1 #对上面的代码进行修改
    2 match3 = re.match(r'[1-9]d{5}','100081 BIT')
    3 if match3:
    4     print(match3.group(0))
    5 
    6 #输出:'100081'

    •re.findall(pattern,string,flags=0)

    (1)findall函数实例(返回的是列表类型)

    1 import re 
    2 ls = re.findall(r'[1-9]d{5}','BIT100081 CLS100084')
    3 print(ls)#['100081','100042'],将所有匹配的输出
    4 for i in ls:
    5     print(i)
    6 #100081
    7 #100084

    •re.split(pattern,string,maxsplit,flags=0)

    参数 说明
    maxsplit 最大分割数,剩余部分作为最后一个元素输出
    1 import re
    2 print(re.split(r'[1-9]d{5}','BIT100081 TSU100084'))
    3 #re.split()是将匹配到的字符串删去以列表的形式输出
    4 print(re.split(r'[1-9]d{5}','BST100081 TSU100084',maxsplit=1))
    5 #maxsplit=n的作用是只匹配前n个匹配到的字符串,不管后面的是否匹配都不管

    •re.finditer(pattern,string,maxsplit,flags=0)

     1 import re
     2 m = re.finditer(r'[1-9]d{5}','BIT100081 TSU100084')
     3 #re.finditer返回的是迭代类型
     4 #如果此时运行print(m),输出是<callable_iterator object at 0x0000024203F83E10>
     5 for i in m:
     6     print(i)
     7 #输出:
     8 #<re.Match object; span=(3, 9), match='100081'>
     9 #<re.Match object; span=(13, 19), match='100084'>
    10 #正确的输出格式
    11 for m in re.finditer(r'[1-9]d{5}','BIT100081 TSU100084'):
    12     if(m):
    13         print(m.group(0))
    14 #100081
    15 #100084

    •re.sub(pattern,repl,string,count=0,flags=0)

    参数 说明
    repl 替换匹配字符串的字符串
    count 匹配的最大替换次数

     

    1 import re
    2 print(re.sub(r'[1-9]d{5}',':zipcode','BIT100081 TSU100084'))
    3 #BIT:zipcode TSU:zipcode
    4 print(re.sub(r'[1-9]d{5}',':zipcode','BIT100081 TSU100084',count=1))
    5 #BIT:zipcode TSU100084

    三、Re库的另一种等价用法:

    rst = re.compile(pattern,flags=0)

    1 rst = re.search(r'[1-9]d{5}','BIT100081 TSU100084')
    2 #函数式用法:一次性操作
    3 pat = re.compile(r'[1-9]d{5}')#此时经过compile的pat才是一个正则表达式
    4 rst = pat.search('BIT100081 TSU100084')
    5 #面向对像用法:编译后的多次操作

    四、Match对象的基本属性:

    属性 说明
    .string 待匹配的文本
    .re 匹配时使用的pattern对象(正则表达式)
    .pos 正则表达式搜索文本的开始位置
    .endpos 正则表达式搜索文本的结束位置

    五、Match对象的方法:

    方法 说明
    .group(0) 获得匹配后的字符串
    .start() 匹配字符串在原始字符串的开始位置
    .end() 匹配字符串在原始字符串的结束位置
    .span() 返回(.start(), .end())元组类型

    六、贪婪匹配算法:

    1 import re
    2 match4 = re.search(r'PY.*N','PYBNCNDN')
    3 print(match4.group(0))
    4 #默认匹配最长的一个字符串,PYBNCNDN
    5 
    6 #那么如何让它匹配最短的字符串呢?
    7 match4 = re.search(r'PY.*?N','PYBNCNDN')
    8 #PYBN

    七、最小匹配操作符:

    操作符 说明
    *? 前一个字符0次或无限次扩展,最小匹配
    +? 前一个字符1次或无限次扩展,最小匹配
    ?? 前一个字符0次或1次扩展,最小匹配
    {m,n}? 扩展前一个字符m至n次(含n),最小匹配
  • 相关阅读:
    项目实战从 0 到 1 学习之Flink (24)Flink将kafka的数据存到redis中
    LeetCode107. 二叉树的层次遍历 II
    LeetCode102. 二叉树的层序遍历
    LeetCode341. 扁平化嵌套列表迭代器
    【总结】二叉树的前中后序遍历(递归和非递归)
    LeetCode145. 二叉树的后序遍历
    LeetCode94. 二叉树的中序遍历
    LeetCode144. 二叉树的前序遍历
    LeetCode71. 简化路径
    LeetCode150. 逆波兰表达式求值
  • 原文地址:https://www.cnblogs.com/BASE64/p/10310314.html
Copyright © 2020-2023  润新知