精华内容
下载资源
问答
  • 今天小编就为大家分享一篇Python 正则表达式 re.match/re.search/re.sub的使用解析,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • re.match()正则表达式

    2021-03-08 13:44:34
    result = re.match("chinahadoop","chinahadoop.cn") #打印匹配出来的内容 print(result.group()) #运行结果:chinahadoop 字符 描述 . 匹配除“\n”之外的任意单个字符 \d 匹配0到9之间的一个数字,等价于[0-9] \D...
    import re
    #匹配以chinahadoop开头的字符串
    result = re.match("chinahadoop","chinahadoop.cn")
    #打印匹配出来的内容
    print(result.group())
    #运行结果:chinahadoop
    

    字符 描述
    . 匹配除“\n”之外的任意单个字符
    \d 匹配0到9之间的一个数字,等价于[0-9]
    \D 匹配一个非数字字符,等价于[^0-9]
    \s 匹配任意空白字符,如空格、制表符“\t”、换行“\n”等
    \S 匹配任意非空白字符
    \w 匹配任意字母或者数字或下划线,如a-z,A-Z,0-9,
    \W 匹配任意非单词字符,等价于[^ a-zA-Z0-9
    ]
    [ ] 匹配[ ]中列举的字符
    ^ 取反

    import re
    # . 匹配除“\n”之外的任意单个字符
    rs = re.match(".","1")
    print(rs.group())
    rs = re.match(".","a")
    print(rs.group())
    rs = re.match(".","abc")  #只匹配单个字符
    print(rs.group())
    rs = re.match("...","abc")  #用3个点匹配3个字符
    print(rs.group())
    

    运行结果:
    1
    a
    a
    abc

    示例:\w匹配单词字符(包括 _ )
    rs = re.match("\w","a")
    print(rs.group())
    rs = re.match("\w","A")
    print(rs.group())
    rs = re.match("\w","1")
    print(rs.group())
    rs = re.match("\w","_")
    print(rs.group())
    rs = re.match("\w","*") #将不会匹配*,返回none
    print(type(rs))
    

    运行结果:

    a
    A
    1
    _
    <class ‘NoneType’>

    示例:匹配[ ]中列举的字符,列举的字符之间相当于是或的关系
    #匹配以h或者H开头的字符串
    rs = re.match("[Hh]", "hello")
    print(rs.group()) 
    # 匹配0到9任意一个数字方法一
    rs = re.match("[0123456789]", "3")
    print(rs.group())
    # 匹配0到9任意一个数字方法二
    rs = re.match("[0-9]", "3")
    print(rs.group())
    

    运行结果:
    h
    3
    3

    在使用正则表达式的过程中,不可能只针对单个字符匹配,很多时候要对多次出现的字符进行匹配,下面介绍正则表达式的数量表示方法。

    字符 描述
    * 一个字符可以出现任意次,也可以一次都不出现
    + 一个字符至少出现一次
    ? 一个字符至多出现一次
    {m} 一个字符出现m次
    {m,} 一个字符至少出现m次
    {m,n} 一个字符出现m到n次
    示例:“*”一个字符可以出现任意次,也可以一次都不出现

    rs = re.match("1\d*","1234abc")#匹配以1开头,后边是任意多个数字,数字有其他字符,也只匹配数字
    print(rs.group())
    

    运行结果:

    1234
    示例:"+"一个字符至少出现一次

    #字符开头至少出现一个数字

    rs = re.match("\d+","1abc") #开头只出现1个数字,符合规则
    print(rs.group())
    rs = re.match("\d+","123abc") #开头出现多个数字,符合规则
    print(rs.group())
    

    运行结果:

    1
    123
    示例:“?”一个字符至多出现一次

    #匹配开头出现一次的数字字符

    rs = re.match("\d?","1abc")
    print(rs.group())
    #开头数字至多出现一次
    rs = re.match("\d?","123abc")  #在1之后的所有数字字符都不会匹配上
    print(rs.group())
    

    运行结果:

    1
    1
    示例:{m} 出现m次

    rs = re.match("\d{3}","123abc")  #要连续出现3次数字
    print(rs.group())
    #要连续出现4次数字,字符串中只出现了3次,与规则不匹配
    rs = re.match("\d{4}","123abc")  
    print(type(rs))
    

    运行结果:

    123
    <class ‘NoneType’>
    示例:{m,} 至少出现m次

    rs = re.match("\d{0,}","123abc")  #等价于*,0次或者多次
    print(rs.group())
    rs = re.match("\d{1,}","123abc")  #等价于+,至少出现一次
    print(rs.group())
    rs = re.match("\d{0,1}","123abc") #等价于?,至多1次,0次或者1次
    print(rs.group())
    

    运行结果:

    123
    123
    1
    综合练习:匹配一个手机号

    手机号一共11位,第1位是1,第2位是3、5、7、8,第3位到第11位是0-9的数字

    代码实现:

    rs = re.match("1[3578]\d{9}","13612345678") #匹配成功
    print(rs.group())
    #用一个错误的手机号测试
    rs = re.match("1[3578]\d{9}","14612345678") #匹配失败,第2位没有出现3、5、7、8
    print(type(rs))
    #11位电话号码+字符测试
    rs = re.match("1[3578]\d{9}","13612345678abc")
    print(rs.group())
    #没有限制边界,也会认为是合法的手机号,后续的“边界表示”课时会介绍如何限定正则表达式的开始和结束边界
    

    运行结果:

    13612345678
    <class ‘NoneType’>
    13612345678

    展开全文
  • 1,re模块之match的基本使用 ** 1,可使用re模块,通过正则表达式对字符串进行匹配 2,re.match函数 尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match()就返回none。 3,函数语法为:...

    1,re模块之match的基本使用

    **

    1,可使用re模块,通过正则表达式对字符串进行匹配

    2,re.match函数 尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match()就返回none。

    3,函数语法为:re.match(pattern, string, flags=0)

    4,参数说明
    pattern 匹配的正则表达式
    string 要匹配的字符串。
    flags 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

    5,匹配成功re.match方法返回一个匹配的对象,否则返回None。

    6,我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

    7,匹配对象方法描述
    group(num=0) 匹配的整个表达式的字符串,group() 可以一次输入多个组号,在这种情况下它将返回一个包含那些组所对应值的元组。
    groups() 返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。

    import re
    pattern = "hello"
    str = "Helloworld"
    result = re.match(pattern, str)
    print(result)
    

    运行结果为:

    None
    

    之所以返回结果为None,是因为严格区分大小写
    修改代码之后的验证如下:

    import re
    pattern = "Hello"
    str = "Helloworld Hello"
    v = re.match(pattern, str)
    print(v)
    print(type(v))
    print(dir(v))
    print(v.group())    # group查找匹配的内容
    print(v.span())     # span匹配的内容的索引范围
    print(v.start())
    print(v.end())
    print(v.string)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 5), match='Hello'>
    <class '_sre.SRE_Match'>
    ['__class__', '__copy__', '__deepcopy__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'end', 'endpos', 'expand', 'group', 'groupdict', 'groups', 'lastgroup', 'lastindex', 'pos', 're', 'regs', 'span', 'start', 'string']
    Hello
    (0, 5)
    0
    5
    Helloworld Hello
    

    当首个单词不匹配时,验证如下:

    import re
    pattern = "Hello"
    str = "helloworld Hello"
    v = re.match(pattern, str)
    print(v)
    

    运行结果为:

    None #原因是re.match函数只匹配字符串的起始位置,如果匹配不成功,就直接返回None
    

    如果想匹配字符串的其他位置,需要用re.search()函数 验证如下:

    import re
    pattern = "Hello"
    str = "helloworld Hello"
    v = re.search(pattern, str)
    print(v)
    print(v.group())
    print(v.span())
    

    运行结果为:

    <_sre.SRE_Match object; span=(11, 16), match='Hello'>
    Hello
    (11, 16)
    

    **

    2,正则表达式之匹配字符

    **
    在这里插入图片描述
    . 点的演示如下:

    import re
    pattern = "."
    str1 = "h"
    str2 = "H"
    str3 = "-"
    str4 = "6"
    str5 = "\n"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    v4 = re.match(pattern, str4)
    v5 = re.match(pattern, str5)
    print(v1)
    print(v2)
    print(v3)
    print(v4)
    print(v5)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 1), match='h'>
    <_sre.SRE_Match object; span=(0, 1), match='H'>
    <_sre.SRE_Match object; span=(0, 1), match='-'>
    <_sre.SRE_Match object; span=(0, 1), match='6'>
    None
    

    \d的演示如下:

    import re
    pattern = "\d"
    str1 = "9"
    str2 = "a"
    str3 = "_"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    print(v1)
    print(v2)
    print(v3)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 1), match='9'>
    None
    None
    

    \D 的演示如下:

    import re
    pattern = "\D"
    str1 = "9"
    str2 = "a"
    str3 = "_"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    print(v1)
    print(v2)
    print(v3)
    

    运行结果为:

    None
    <_sre.SRE_Match object; span=(0, 1), match='a'>
    <_sre.SRE_Match object; span=(0, 1), match='_'>
    

    \s 匹配\r \t \n 的演示如下:

    import re
    pattern = "\s"
    str1 = " "
    str2 = "\t"
    str3 = "\n"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    print(v1)
    print(v2)
    print(v3)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 1), match=' '>
    <_sre.SRE_Match object; span=(0, 1), match='\t'>
    <_sre.SRE_Match object; span=(0, 1), match='\n'>
    

    \S 的演示如下:

    import re
    pattern = "\S"
    str1 = " "
    str2 = "\t"
    str3 = "\n"
    str4 = "a"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    v4 = re.match(pattern, str4)
    print(v1)
    print(v2)
    print(v3)
    print(v4)
    

    运行结果为:

    None
    None
    None
    <_sre.SRE_Match object; span=(0, 1), match='a'>
    

    \w 的演示如下:

    import re
    pattern = "\w"
    str1 = " "
    str2 = "\t"
    str3 = "9"
    str4 = "$"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    v4 = re.match(pattern, str4)
    print(v1)
    print(v2)
    print(v3)
    print(v4)
    

    运行结果为:

    None
    None
    <_sre.SRE_Match object; span=(0, 1), match='9'>
    None
    

    \W 的演示如下:

    import re
    pattern = "\W"
    str1 = " "
    str2 = "\t"
    str3 = "9"
    str4 = "$"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    v4 = re.match(pattern, str4)
    print(v1)
    print(v2)
    print(v3)
    print(v4)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 1), match=' '>
    <_sre.SRE_Match object; span=(0, 1), match='\t'>
    None
    <_sre.SRE_Match object; span=(0, 1), match='$'>
    

    [ ] 的演示如下:

    import re
    pattern = "[1,3,5,7,9]"
    str1 = " "
    str2 = "1"
    str3 = "9"
    str4 = "$"
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    v4 = re.match(pattern, str4)
    print(v1)
    print(v2)
    print(v3)
    print(v4)
    

    运行结果为:

    None
    <_sre.SRE_Match object; span=(0, 1), match='1'>
    <_sre.SRE_Match object; span=(0, 1), match='9'>
    None
    

    需求:匹配手机号,11位数

    import re
    pattern = "1[35789]\d\d\d\d\d\d\d\d\d"
    str1 = "19812341234"
    v1 = re.match(pattern, str1)
    
    print(v1)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 11), match='19812341234'>
    

    **

    3,正则表达式之表示数量

    **
    在这里插入图片描述
    *的演示如下

    import re
    pattern = "\d*"
    s1 = "123abc"
    s2 = "abc"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 3), match='123'>
    <_sre.SRE_Match object; span=(0, 0), match=''>
    

    + 的演示如下:

    import re
    pattern = "\d+"
    s1 = "123abc"
    s2 = "abc"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 3), match='123'>
    None
    

    ?的使用演示如下:

    import re
    pattern = "\d?"
    s1 = "123abc"
    s2 = "abc"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 1), match='1'>
    <_sre.SRE_Match object; span=(0, 0), match=''>
    

    {m}的使用演示如下:

    import re
    pattern = "\d{3}"
    s1 = "123abc"
    s2 = "abc"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 3), match='123'>
    None
    

    {m,n}的使用演示如下:

    import re
    pattern = "\d{2,4}"  # 代表匹配2个或者3个或者4个
    s1 = "123abc"
    s2 = "1abc"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 3), match='123'>
    None
    

    {m,}的使用演示如下:

    import re
    pattern = "\d{2,}"  # 代表代表至少匹配2个数字
    s1 = "123abc"
    s2 = "abc"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 3), match='123'>
    None
    

    需求:匹配出一个字符串首字母为大写字母,后边都是小写字符,这些小写字母可有可无

    import re
    pattern = "[A-Z][a-z] * " 
    s1 = "Hello"
    s2 = "HEllo"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 5), match='Hello'>
    <_sre.SRE_Match object; span=(0, 1), match='H'>
    

    需求:匹配出有效的变量名

    import re
    pattern = "[A-Za-z_][A-Za-z0-9_]*"  # 等价于"[A-Za-z_]\w*"
    s1 = "Hb2"
    s2 = "2hb"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 3), match='Hb2'>
    None
    

    需求:匹配1-99之间的数字

    import re
    pattern = "[1-9][0-9]?"
    s1 = "33"
    s2 = "123"
    s3 = "0"
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    v3 = re.match(pattern, s3)
    print(v1)
    print(v2)
    print(v3)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 2), match='33'>
    <_sre.SRE_Match object; span=(0, 2), match='12'>
    None
    

    需求:匹配出一个随机密码8-20位以内(大小写字母 数字 下划线)

    import re
    pattern = "\w{8,20}"
    s1 = "33agcdefg"
    s2 = "123agc"
    
    v1 = re.match(pattern, s1)
    v2 = re.match(pattern, s2)
    
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 9), match='33agcdefg'>
    None
    

    **

    4,正则表达式之原始字符串

    **
    概述:python中字符串前边加上r表示原生字符串

    示例代码如下:

    import re
    v1 = r"\nabc"
    v2 = "\nabc"
    v3 = "\\nabc"
    
    print(v1)
    print(v2)
    print(v3)
    

    运行结果为:

    \nabc
    
    abc   # 打印此结果之前出现了换行 因为字符串前面没有加r ,\n就代表换行符
    \nabc
    

    示例2如下:

    import re
    pattern = r"\\\\n\d{3,}"
    str = "\\\\n123"
    result = re.match(pattern, str)
    print(result)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 6), match='\\\\n123'>
    
    

    **

    5,正则表达式之表示边界

    **
    在这里插入图片描述
    需求:匹配QQ邮箱 5-10位,@qq.com

    import re
    pattern = r"[1-9]\d{4,9}@qq.com"
    str = "1297685567@qq.com.cn"   
    result = re.match(pattern, str)
    print(result)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 17), match='1297685567@qq.com'>
    

    注意:以上代码是错误的 str字符串不是QQ邮箱的正确格式
    修改后的代码如下:

    import re
    pattern = r"[1-9]\d{4,9}@qq.com$"
    str = "1297685567@qq.com.cn"
    result = re.match(pattern, str)
    print(result)
    

    运行结果为:

    None
    

    需求:使用\b匹配单词边界

    import re
    pattern1 = r".*\ber"        # 匹配左边界
    pattern2 = r".*er\b"        # 匹配右边界
    str1 = "123 eroa"
    str2 = "123,oaer"
    v1 = re.match(pattern1, str1)
    v2 = re.match(pattern2, str2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 6), match='123 er'>
    <_sre.SRE_Match object; span=(0, 8), match='123,oaer'>
    

    需求:使用\B匹配非单词边界

    import re
    pattern1 = r".*\Ber"        # 匹配非单词左边界
    pattern2 = r".*er\B"        # 匹配非单词右边界
    str1 = "123 Peroa"
    str2 = "123,oaer"
    v1 = re.match(pattern1, str1)
    v2 = re.match(pattern2, str2)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 7), match='123 Per'>
    None
    

    **

    6,正则表达式之匹配分组

    **
    在这里插入图片描述
    | 的使用需求:匹配0-100之间所有的数字

    import re
    pattern = r"[0-9]?\d$|100$"
    str1 = "1000"
    str2 = "0"
    str3 = "99"
    str4 = "100"
    
    v1 = re.match(pattern, str1)
    v2 = re.match(pattern, str2)
    v3 = re.match(pattern, str3)
    v4 = re.match(pattern, str4)
    
    print(v1)
    print(v2)
    print(v3)
    print(v4)
    

    运行结果为:

    None
    <_sre.SRE_Match object; span=(0, 1), match='0'>
    <_sre.SRE_Match object; span=(0, 2), match='99'>
    <_sre.SRE_Match object; span=(0, 3), match='100'>
    

    需求:匹配座机号码 区号-电话号{5,8} 演示(ab)的使用

    import re
    pattern = r"(\d{3,4})-([1-9]\d{4,7})$"
    str1 = "0178-55559999"
    
    v1 = re.match(pattern, str1)
    print(v1)
    print(v1.group())
    print(v1.group(1))
    print(v1.group(2))
    print(v1.groups())
    print(v1.groups()[0])
    print(v1.groups()[1])
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 13), match='0178-55559999'>
    0178-55559999
    0178
    55559999
    ('0178', '55559999')
    0178
    55559999
    

    \num 的演示如下:需求匹配出网页标签内的数据

    import re
    pattern = r"<(.+)><(.+)>.+</\2></\1>"  # \2对应第二个括号中的.+  \1对应第一个括号中的.+
    str1 = "<html><title>我是魔鬼标题</title></html>"
    
    v1 = re.match(pattern, str1)
    print(v1)
    

    运行结果为

    <_sre.SRE_Match object; span=(0, 34), match='<html><title>我是魔鬼标题</title></html>'>
    

    (?P<>)的用法演示如下****需求:匹配分组别名以及引用别名 注意P是大写的

    import re
    # pattern = r"<(.+)><(.+)>.+</\2></\1>" 改版后的标题如下
    pattern = r"<(?P<标签1>.+)><(?P<标签2>.+)>.+</(?P=标签2)></(?P=标签1)>"  # 标签1标签2是随便起的组名
    
    str1 = "<html><title>我是魔鬼标题</title></html>"
    
    v1 = re.match(pattern, str1)
    print(v1)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 34), match='<html><title>我是魔鬼标题</title></html>'>
    

    **

    7,正则表达式之高级用法

    **
    1,search:扫描字符串,查找正则表达式模式产生匹配的第一个位置,并返回相应的匹配对象。如果字符串中没有与模式匹配的位置,则返回None

    2,findall:从左到右扫描字符串,并按照找的顺序返回匹配。如果模式中有一个或多个组,返回组列表

    import re
    pattern = r"\d+"
    str1 = "python阅读次数为999次,java阅读次数为888次,c阅读次数为666次"
    
    # search从前往后找,找到一个之后就直接返回
    v1 = re.search(pattern, str1)
    
    # findall 返回与表达式相匹配的所有内容 ,返回的是一个列表
    v2 = re.findall(pattern, str1)
    
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(11, 14), match='999'>
    ['999', '888', '666']
    

    3,sub:返回通过替换rep|替换字符串中最左边不重叠的模式出现而得到的字符串,如果没有找到模式,则返回字符串不变

    用法1:直接替换 演示如下:

    import re
    pattern = r"\d+"
    str1 = "python阅读次数为999次,java阅读次数为888次,c阅读次数为666次"
    
    # count值设为0,或者不写 默认替换所有
    v1 = re.sub(pattern,"100", str1, count=0)
    
    # 注意返回的是一个替换之后的新的字符串对象
    print(v1)
    

    运行结果为:

    python阅读次数为100次,java阅读次数为100次,c阅读次数为100次
    

    用法2:使用函数(可以运算)替换(常用)

    import re
    pattern = r"\d+"
    str1 = "python阅读次数为100次,java阅读次数为1000次,c阅读次数为10000次"
    
    def replace(result):
        # print(result)
        # print(type(result.group()))
        return str(int(result.group())+1)
    
    v = re.sub(pattern, replace, str1)
    print(v)
    

    运行结果为:

    python阅读次数为101次,java阅读次数为1001次,c阅读次数为10001次
    

    4,split:通过指定模式拆分字符串(按指定的格式拆分字符串)

    import re
    pattern = r"\s|:|,"
    str1 = "He say:learn,python"
    
    v = re.split(pattern, str1)
    
    # 注意返回的结果是一个列表
    print(v)
    

    运行结果为:

    ['He', 'say', 'learn', 'python']
    

    **

    8,正则表达式之贪婪模式和非贪婪模式

    **
    贪婪模式:python里数量词默认是贪婪的,总是尝试匹配尽可能多的字符

    非贪婪模式:与贪婪相反,总是尝试匹配尽可能少的字符,可使用"*" “?” “+” "{m, n}"后面加上?,使贪婪变非贪婪

    import re
    
    # 贪婪模式
    pattern1 = r"abc\d+"
    
    # 非贪婪模式
    pattern2 = r"abc\d+?"
    
    str = "abc123"
    
    v1 = re.match(pattern1, str)
    v2 = re.match(pattern2, str)
    print(v1)
    print(v2)
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 6), match='abc123'>
    <_sre.SRE_Match object; span=(0, 4), match='abc1'>
    

    示例二如下:

    import re
    
    # 贪婪模式
    pattern1 = r"(.+)(\d+)-(\d+)-(\d+)"
    
    # 非贪婪模式
    pattern2 = r"(.+?)(\d+)-(\d+)-(\d+?)"
    
    str = "this is my tel:186-1234-1234"
    
    v1 = re.match(pattern1, str)
    v2 = re.match(pattern2, str)
    print(v1)
    print(v1.group(1))
    print(v1.group(2))
    print(v1.group(3))
    print(v1.group(4))
    print("--" * 35)
    print(v2)
    print(v2.group(1))
    print(v2.group(2))
    print(v2.group(3))
    print(v2.group(4))
    

    运行结果为:

    <_sre.SRE_Match object; span=(0, 28), match='this is my tel:186-1234-1234'>
    this is my tel:18
    6
    1234
    1234
    ----------------------------------------------------------------------
    <_sre.SRE_Match object; span=(0, 25), match='this is my tel:186-1234-1'>
    this is my tel:
    186
    1234
    1
    

    **

    以上

    **
    如有错误 欢迎指正
    欢迎 粘贴 复制 评论 转发 点赞

    **

    轻轻一点 好运连连

    **

    展开全文
  • python re.match()用法相关示例

    千次阅读 2021-02-03 09:28:21
    学习python爬虫时遇到了一个问题,书上有示例如下:import reline='cats are smarter than dogs'matchobj=re.match(r'(.*)are(.*?).*',line)if matchobj:print('matchobj.group():',matchobj.group())print('...

    学习python爬虫时遇到了一个问题,书上有示例如下:

    import re

    line='cats are smarter than dogs'

    matchobj=re.match(r'(.*)are(.*?).*',line)

    if matchobj:

    print('matchobj.group():',matchobj.group())

    print('matchobj.group(1):', matchobj.group(1))

    print('matchobj.group(2):', matchobj.group(2))

    else:

    print('no match!\n')

    书上的期望输出是:

    matchobj.group(): cats are smarter than dogs

    matchobj.group(1): cats

    matchobj.group(2):smarter

    但是我在电脑上跑了一遍得到的输出却是:

    matchobj.group(): cats are smarter than dogs

    matchobj.group(1): cats

    matchobj.group(2):

    于是开始想办法彻底搞清楚这个差别的原因所在。

    首先要读懂这几行代码,而这一行代码的关键在于这一句:

    matchobj=re.match(r'(.*)are(.*?).*',line)

    匹配的正则表达式是

    (.*)are(.*?).*

    前面的r表示的是匹配的字符不进行转义,而要匹配的字符串是line,也就是

    cats are smarter than dogs

    后面使用group(num),个人理解是,按照正则表达式中的括号数可以捕获得到对应数量的捕获组,而调用group(num)就可以得到对应捕获组的内容,

    其中group(0)表示的是匹配的整个表达式的字符串,在本例中就是‘cats are smarter than dogs'。

    参照网上可以搜到的符号的作用:

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

    *重复之前的字符零次或更多次

    ?重复之前的字符零次或一次

    那么第一个括号的内容,应当就是匹配要匹配的字符串中are之前的所有字符(除换行符),

    而第二个括号的内容应当是匹配are之后的内容,但具体想指代什么却显得有些不明确。

    不明确的点就在于*和?这两个符号的连用,根据优先级这两个符号是同一优先级的,那么应当按照顺序生效,那么如此翻译的话,这一语句匹配的就是长度为0到无限大的任意字符串,为了探清此时

    程序判断的具体内容,我们给匹配字符串末尾的.*也加上括号以提取其内容,而后在输出部分加上对应语句:

    import re

    line='cats are smarter than dogs'

    matchobj=re.match(r'(.*)are(.*?)(.*)',line)

    if matchobj:

    print("matchobj.group():",matchobj.group())

    print("matchobj.group(1):", matchobj.group(1))

    print("matchobj.group(2):", matchobj.group(2))

    print("matchobj.group(3):", matchobj.group(3))

    else:

    print('no match!\n')

    得到的结果是:

    matchobj.group(): cats are smarter than dogs

    matchobj.group(1): cats

    matchobj.group(2):

    matchobj.group(3):  smarter than dogs

    可见第二个括号里的内容被默认为空了,然后删去那个?,可以看到结果变成:

    matchobj.group(): cats are smarter than dogs

    matchobj.group(1): cats

    matchobj.group(2):  smarter than dogs

    matchobj.group(3):

    那么这是否就意味着?的默认值很可能是0次,那?这个符号到底有什么用呢

    仔细想来这个说法并不是很严谨。尝试使用单独的.?组合可以看到这个组合可以用于提取

    单个不知道是否存在的字符,而如下代码

    import re

    line='cats are smarter than dogs'

    matchobj=re.match(r'(.*) are(.*)?',line)

    if matchobj:

    print("matchobj.group():",matchobj.group())

    print("matchobj.group(1):", matchobj.group(1))

    print("matchobj.group(2):", matchobj.group(2))

    也能在组别2中正常提取到are之后的字符内容,但稍微改动一下将?放到第二个括号内,

    就什么也提取不到,同时导致group(0)中匹配的字符到cats are就截止了(也就是第二个括号匹配失败)。

    令人感到奇怪的是,如果将上面的代码改成

    import re

    line='cats are smarter than dogs'

    matchobj=re.match(r'(.*) are (.*)+',line)

    if matchobj:

    print("matchobj.group():",matchobj.group())

    print("matchobj.group(1):", matchobj.group(1))

    print("matchobj.group(2):", matchobj.group(2))

    也就是仅仅将?改为+,虽然能成功匹配整个line但group(2)中没有内容,

    如果把+放到第二个括号中就会产生报错,匹配失败。

    那么是否可以认为.*?这三个符号连用只是一个不规范的操作,但由于?的特殊性所以没有报错反而匹配成功了呢?

    具体的可能要研究代码本身的机理了,暂且搁置。还有一个问题就是如何达到样例本身想要的,用第二个括号提取单个单词的目的。

    如果单单考虑这个例子的话,把原本第二个括号中的?换成r就可以了,也就是如下代码:

    import re

    line='cats are smarter than dogs'

    matchobj=re.match(r'(.*) are (.*r).*',line)

    if matchobj:

    print("matchobj.group():",matchobj.group())

    print("matchobj.group(1):", matchobj.group(1))

    print("matchobj.group(2):", matchobj.group(2))

    #print("matchobj.group(3):", matchobj.group(3))

    else:

    print('no match!\n')

    为了泛用性尝试了一下把r改成‘ '但是得到的结果是‘smarter than '。于是尝试把.换成表示任意字母的

    [a-za-z],成功提取出了单个smarter,代码如下:

    import re

    line='cats are smarter than dogs'

    matchobj=re.match(r'(.*) are ([a-za-z]* ).*',line)

    if matchobj:

    print("matchobj.group():",matchobj.group())

    print("matchobj.group(1):", matchobj.group(1))

    print("matchobj.group(2):", matchobj.group(2))

    #print("matchobj.group(3):", matchobj.group(3))

    else:

    print('no match!\n')

    到此这篇关于python re.match()用法相关示例的文章就介绍到这了,更多相关python re.match()内容请搜索萬仟网以前的文章或继续浏览下面的相关文章希望大家以后多多支持萬仟网!

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • 经过调研发现了Rematch库:Redux是一个出色的状态管理工具,并且有着健全的中间件生态以及出色的开发工具;Rematch是没有boilerplate的Redux最佳实践。移除了声明action类型、action创建函数、thunks、store配置、...

    摘要

    近期在优化团队代码,发现Redux重复使用的代码过多。 经过调研发现了Rematch库:Redux是一个出色的状态管理工具,并且有着健全的中间件生态以及出色的开发工具;Rematch是没有boilerplate的Redux最佳实践。移除了声明action类型、action创建函数、thunks、store配置、mapDispatchToProps、sagas等东西,大大简化了代码。故今天就来分享rematch的用法。

    Rematch的用法

    1.初始化全局设置store

    Init(config):初始化Rematch,在init中可以配置属于自己的使用的config参数。

    Models:导出和存储项目的状态管理,models详细的参数说明可以到官网查看文档进行阅读。

    Plugins:用来自定义init配置或背部hooks,可以添加功能来设置Rematch,更多的插件可以阅读官网插件的API进行学习。

    Redux:可以对redux设置访问以及覆盖redux方法的选项,可以保留redux中优秀的方法等。

    import { init } from '@rematch/core';

    import thunk from 'redux-thunk';

    import immerPlugin from '@rematch/immer';

    import selectPlugin from '@rematch/select';

    import createLoadingPlugin from '@rematch/loading';

    import { createLogger } from 'redux-logger';

    import * as models from './models';

    const middlewares = [thunk];

    if (process.env.NODE_ENV === 'development') {

    middlewares.push(createLogger())

    }

    export const createStore = initialState => init({

    models: {

    ...models

    },

    plugins: [immerPlugin(), createLoadingPlugin(), selectPlugin()],

    redux: {

    initialState: initialState,

    middlewares: middlewares,

    devtoolOptions: {

    disabled: process.env.NODE_ENV === 'production',

    },

    }

    })

    const store = createStore();

    export default store;

    2.将初始化store引入index.js文件

    Rematch是Redux的最佳实践,所以store的注入方式保持redux原有的注入方式。

    import React from 'react';

    import ReactDOM from 'react-dom';

    import { Provider } from "react-redux";

    import App from './App';

    import store from './store';

    import './index.css';

    ReactDOM.render(

    ,

    document.getElementById('root')

    );

    3.建立models状态管理文件

    创建models文件夹,导出所有的model模块。

    import count from './count';

    import lessons from './lessons';

    export {

    count,

    lessons

    };

    创建数字计数器状态管理count.js

    const initState = {

    number: 0

    };

    const count = {

    state: initState,

    reducers: {

    increase(state, payload) {

    const { number } = state;

    state.number = number + payload;

    return state;

    },

    decrease(state, payload) {

    const { number } = state;

    state.number = number - payload;

    return state;

    }

    },

    effects: dispatch => ({})

    }

    export default count;

    4.state应用到相对应的组件

    Rematch只是优化了Redux中重复的代码段,所以状态的使用以及更新状态的方法还是沿用redux的方式。

    import React from 'react';

    import { connect } from 'react-redux';

    const Count = ({

    number,

    increase,

    decrease

    }) => {

    return (

    数字计数器

    {number}

    increase(1)}>点击加1

    decrease(1)}>点击减1

    )

    }

    const mapStateToProps = state => ({

    number: state.count.number

    })

    const mapDispatchToProps = dispatch => ({

    increase: dispatch.count.increase,

    decrease: dispatch.count.decrease

    })

    export default connect(mapStateToProps, mapDispatchToProps)(Count);

    测试结果

    f024b17b4987c80ba982e66a5caa739e.gif

    总结

    Rematch是Redux实践的最佳方式,极大的简化了项目中的代码量。虽然Rematch极大的优化了项目的代码数量问题,也更简洁明了的区分了不同组件的不同状态管理文件,但是Rematch依旧存在着一些不可避免的小问题,比如state持久化等。这次分享只是简单的展示了Rematch的用法,后续会持续更新更复杂、更多样性的状态数据处理案例。

    版权声明:本文为博主原创文章,转载请附上原文出处链接和本声明。

    展开全文
  • 一、re模块(re.match、group()方法) 1、 2、re.match() 能够匹配出以xxx开头的字符串(从左到右开始依次匹配) 3、若匹配成功,返回字符串的匹配成功的部分,同时可以使用group方法来提取具体的数据。 二...
  • 单个字符: 数量词: 匹配开头、结尾: ...demo.py(正则表达式,match从开头匹配,分组,分组别名): ...ret = re.match(r"&lt;(\w*)&gt;&lt;(\w*)&gt;.*&lt;/\2&gt;&l...
  • re模块为Python提供了正则表达式的相关操作,但是很多的方法因为相似度较大,因此经常造成一些混乱,在这里写一份笔记提供参考(方法里的可选参数就不讲了,因为一般也用不着)。 1. match和fullmatch 1.1 match ...
  • 下表是常见的正则表达式属性:函数/方法描述仅仅是re模块函数compile(pattern,flags=0)使用任何可选的标记来编译正则表达式的模式 ,然后返回一个正则表达式对象re模块函数和正则表达式对象的方法match(pattern,...
  • 1.re.match(pattern, string[, flags]) 这个方法从我们要匹配的字符串的头部开始,当匹配到string的尾部还没有匹配结束时,返回None; 当匹配过程中出现了无法匹配的字母,返回None。 下面给出一组代码来进行...
  • 1、先来个官方的ngx.re.match location /ngx_re_match { default_type text/html; content_by_lua_block { local m, err = ngx.re.match("/live/4001493201083.m3u8", "[0-9]+") if m then...
  • 正则表达式(regular expression)是一个特殊的字符序列,描述了一种字符串匹配的模式...Python处理正则表达式的模块是re模块,它是Python语言中拥有全部的正则表达式功能的模块。 正则表达式由一些普通字符和一些...
  • 使用函数 match() 的语法格式如下所示:re.match(pattern, string, flags=0)各参数的具体说明如下:参数pattern:匹配的正则表达式。参数string:要匹配的字符串。参数flags:标志位,用于控制正则表达式的匹配方式...
  • lower = re.compile(r'^([a-z]|_)*$') lower_colon = re.compile(r'^([a-z]|_)*:([a-z]|_)*$') problemchars = re.compile(r'[=\+/& def key_type(element, keys):  #print(element.tag)  if ele
  • re- 正则表达操作

    2019-10-03 20:13:00
    这个模块提供了与 Perl 语言类似的正则表达式匹配操作。 模式和被搜索的字符串既可以是 Unicode 字符串 (str) ...你可能更加愿意使用 search() 函数,而不是 match() 函数: >> > import re >> > m = re . ...
  • (在Python中)它内嵌在Python中,并通过 re 模块实现。正则表达式模式被编译成一系列的字节码,然后由用 C 编写的匹配引擎执行。2.目的和特点给定一个正则表达式和另一个字符串,我们可以达到如下的目的:给定的字符...
  • re模块详解

    2021-02-03 00:16:28
    主要用到的方法列举如下 1 2 3 4 5 6 7 8 9 10 #返回pattern对象 re.compile(string[,flag]) #以下为匹配所用函数 re.match(pattern,string[,flags]) re.search(pattern,string[,flags]) re.split(pattern,string[,...
  • 正则表达式(Regular Expression)使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。 re模块的使用 ...result = re.match(pattern, string) #若匹配成功,则match方法返回匹配对象(Ma...
  • python3正则re的使用

    千次阅读 2019-04-23 16:01:01
    反斜杠二、re模块1.match2.search3.split,findall,finditer三个方法4.sub 一、正则 1.正则表达式定义 正则就是用一些具有特殊含义的符号组合到一起(称为正则表达式)来描述字符或者字符串的方法。或者说:正则就是...
  • python re.sub 正则表达式过滤指定字符实例代码re.sub(pattern, repl, string, count=0, flags=0)Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the ...
  • python re模块

    2021-02-03 00:16:53
    一、简介正则表达式本身是一种小型的、高度专业化的编程语言,而在python中,通过内嵌集成re模块,程序媛们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码,然后由用C编写的匹配引擎执行。二、...
  • 这两天在写爬虫程序,涉及英文文本处理,需要规范化英文标点符号的写法。正常情况下,英文句号「.」后面需要保证有且只有一个...一开始,我的函数是这样写的:1 def punctuate(s):2 #----其余代码暂略3 s = re.su...
  • 正则表达式(称为RE,或正则,或正则表达式模式)本质上是嵌入在Python中的一种微小的、高度专业化的编程语言。re模块提供来正则表达式匹配操作,用来对文本进行一些处理优化。匹配模式和被搜索的字符串既可以是...
  • Python中常用的re

    千次阅读 2020-12-11 05:32:29
    使用re的一般步骤是先将正则表达式的字符串形式编译为Pattern实例,然后使用Pattern实例处理文本并获得匹配结果(一个Match实例),最后使用Match实例获得信息,进行其他的操作。import re#查看re里的函数dir(re)#正则...
  • python 基础 之 正则表达式的知识点整理,并简单使用说明 ...1、match 功能使用讲解 2、 group 功能使用讲解 3、search 功能讲解 4、findall 功能讲解 5、split 功能讲解 6、sub 功能讲...
  • python标准库之re

    2021-03-17 03:21:37
    python则通过re模块来实现。正则表达式的匹配流程python支持的正则表达式元字符和语法1.2贪婪与非贪婪正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),...
  • python 正则表达式(re) 96 thinkando https://www.jianshu.com/p/39fb062abbe0 2017.12.03 23:47 字数 584 阅读 151评论 0喜欢 2 No. 目录 正则表达式概述 re模块介绍 单字符匹配 原始字符窜 多字符匹配 边界匹配...
  • python中re模块知识点总结

    千次阅读 2021-01-29 04:03:11
    看看例子 >>> import re >>> pattern = re.compile('\d+') >>> m = pattern.search('one12twothree34four') # 这里如果使用 match 方法则不匹配 >>> m <_sre.SRE_Match object at 0x10cc03ac0> >>> m.group() '12' ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,273
精华内容 8,509
热门标签
关键字:

matchre数量