精华内容
下载资源
问答
  • 一、re模块(re.match、group()方法) 1、 2、re.match() 能够匹配出以xxx开头的字符串(从左到右开始依次匹配) 3、若匹配成功,返回字符串的匹配成功的部分,同时可以使用group方法来提取具体的数据。 二...

    一、re模块(re.match、group()方法)

    1、

    2、re.match() 能够匹配出以xxx开头的字符串(从左到右开始依次匹配)

    3、若匹配成功,返回字符串的匹配成功的部分,同时可以使用group方法来提取具体的数据。

    二、正则表达式的字符匹配(只匹配1个字符)

    1、. 匹配任意1个字符(除了\n都能匹配)——(例如#、?都能匹配)

    校验一下你字符串当中够不够3个字符:

    2\d 匹配数字,即0-9

    3、\D 匹配非数字,即不是数字

    4、\s(小写) 匹配空白,即空格、\t、\n、\r

    5、\S (大写)匹配非空白

    6、\w(小写)  匹配单词字符,即a-z,A-Z,0-9,_

    7、\W (大写)匹配非单词字符,即不是a-z,A-Z,0-9,_

    8、[ ] :匹配[ ]中列举的字符

    注意:这几个字符之间不能有空格逗号什么的。

    ①  第二位数只要是3 5 7 8 其中的任何一个就可以:

    ② 取反,加个^

    ③ 限制字母、数字

    三、正则数量描述

    1、* 匹配前一个字符出现0次或者无限次,即可有可无

    2、+ 匹配前一个字符出现1次或者无限次,即至少有1次

    3、 匹配前一个字符出现1次或者0次,即要么有1次,要么没有

    4、{m} 匹配前一个字符出现m次(必须满足m次)

    5、{m,} 匹配前一个字符至少出现m次

    6、{m,n} 匹配前一个字符出现从m次到n次

    7、{0,} 可以代表*号的意思——0次或无限次

    8、{1,}  可以代表+号的意思——至少有1次

    9、{0,1}可以代表?号的意思——出现1次或0次

     

     

     

     

     

     

     

     

     

    展开全文
  • 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
    

    **

    以上

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

    **

    轻轻一点 好运连连

    **

    展开全文
  • 单个字符: 数量词: 匹配开头、结尾: ...demo.py(正则表达式,match从开头匹配,分组,分组别名): ...ret = re.match(r"&lt;(\w*)&gt;&lt;(\w*)&gt;.*&lt;/\2&gt;&l...

     

    单个字符:

    数量词:

    匹配开头、结尾:

    匹配分组:

     

    demo.py(正则表达式,match从开头匹配,分组,分组别名):

    # coding=utf-8
    import re
    
    # 小括号()表示分组  \1表示取出第一个分组中匹配的字符串。
    ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", "<html><h1>www.baidu.cn</h1></html>")  # 正则前的r表示原生字符串,取消字符串中反斜杠\的默认转义作用。
    if ret:
    	print("符合要求....匹配成功的整个字符串是:%s" % ret.group())  # <html><h1>www.baidu.cn</h1></html>
    	print("第一个分组:%s" % ret.group(1))  # 第一个分组就是第一个小括号()中匹配的字符串。  html 
    	print("第二个分组:%s" % ret.group(2))  # h1
    else:
    	print("不符合要求....")
    
    
    # ######################################################
    # 分组取别名
    ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>", "<html><h1>www.baidu.cn</h1></html>")
    if ret:
    	print("符合要求....匹配成功的整个字符串是:%s" % ret.group())
    	print("第一个分组:%s" % ret.group(1))  # 第一个分组就是第一个小括号()中匹配的字符串。
    	print("第二个分组:%s" % ret.group(2))
    else:
    	print("不符合要求....")
    
    

    demo.py(.匹配非\n字符。在re.DOTALL模式下可以匹配\n):

    # coding=utf-8
    import re
    
    
    ret = re.match(r".*", "aa\nbb")  # .不会匹配\n
    if ret:
    	print(ret.group())  # aa
    else:
    	print("不符合要求....")
    
    
    
    # ret = re.match(r".*", "aa\nbb", re.DOTALL)
    ret = re.match(r".*", "aa\nbb", re.S)   # re.S 是 re.DOTALL 的简写。 可以让.匹配所有字符,包括\n
    if ret:
    	print(ret.group())   # aa\naa
    else:
    	print("不符合要求....")
    
    

     

    展开全文
  • re模块

    2019-05-07 14:36:00
    目录 匹配模式 标识符flag 字符 预定义字符 数量 边界匹配 逻辑分组 匹配模式 match 从头开始匹配,匹配到用group()返回 s = '1234qych7890' res1 = re.match('[...

    匹配模式

    • match
      从头开始匹配,匹配到用group()返回
    s = '1234qych7890'
    
    res1 = re.match('[0-9]', s).group()  # 1 匹配到第一个数字
    res2 = re.match('[a-z]', s)   # None 第一个不是字母,没匹配到
    • search
      全局匹配,匹配到就返回,用group()取到返回值
    s = '1234qych7890'
    
    res1 = re.search('[0-9]', s).group()  # 1
    res2 = re.search('[a-z]', s).group()  # q
    • findall
      全局匹配,匹配到的所有的用列表返回
    s = '1234qych7890'
    
    res1 = re.findall('[0-9]', s)  # ['1', '2', '3', '4', '7', '8', '9', '0']
    res2 = re.findall('[a-z]', s)  # ['q', 'y', 'c', 'h']
    • split
      匹配到的字符当做列表分隔符,比方说几个字母按数字分开,跟findall相反,参数maxsplit
    s = '12q34qh789f0'
    
    res1 = re.split('[a-z]+', s)  # ['12', '34', '789', '0']
    res1 = re.split('[a-z]+', s,maxsplit=2)  # ['12', '34', '789f0']
    • sub
      匹配字符并替换,sub(pattern,repl,string,count=0,flags=0)
    res1 = re.sub('[a-z]','#', '12q34qh789f0')
    # 12#34##789#0
    • fullmatch
      全部匹配成功才返回
    res1 = re.fullmatch('1234qych7890', '1234qych7890').group()
    # 1234qych7890
    • compile
      制定匹配规则
    s = '1234qych7890'
    
    pattern = re.compile('\d+')
    res1 = pattern.findall(s)  # ['1234', '7890']

    标识符flag

    • I
      忽略大小写
    • M
      多行模式,改变^$,按照一行一行来看了,换行符从符号变成了实际的行
    • S
      改变.,包括了换行符,即所有字符
    • X
      可以添加注释

    字符

    • .
      匹配任意除换行符'\n'外的字符
    res1 = re.findall('.', '1234qych\n7890')
    # ['1', '2', '3', '4', 'q', 'y', 'c', 'h', '7', '8', '9', '0']
    • \
      转义字符

    • [...]
      范围内的字符,^表示取反
    s = '1234qych7890'
    
    res1 = re.findall('[a-z]', s)  #  ['q', 'y', 'c', 'h']
    res1 = re.findall('[^a-z]', s)  #  ['1', '2', '3', '4', '7', '8', '9', '0']

    预定义字符

    • \d
      数字,相当于[0-9]
    res = re.findall('\d', '1234qych7890')
    #  ['1', '2', '3', '4', '7', '8', '9', '0']
    • \D
      非数字,[^\d]
    res = re.findall('\D', '1234qych7890')
    #  ['q', 'y', 'c', 'h']
    • \s
      空白字符串,\t\r\n\f\v
    res = re.findall('\s', '1234qych\n7890')
    #  ['\n']
    • \S
      非空白字符串,[^\s]
    res = re.findall('\S', '1234qych\n7890')
    #  ['1', '2', '3', '4', 'q', 'y', 'c', 'h', '7', '8', '9', '0']
    • \w
      字母数字下划线,[A-Za-z0-9]
    res = re.findall('\w', '1234qych\n7890')
    #  ['1', '2', '3', '4', 'q', 'y', 'c', 'h', '7', '8', '9', '0']
    • \W
      非字母数字下划线,[^\w]
    res = re.findall('\W', '1234qych\n7890')
    #  ['\n']

    数量

    • *
      匹配前一个字符0或者无限次
    res = re.search('ab*', 'abbbcd').group()  # abbb
    res = re.search('ab*', 'aabbbcd').group()  # a
    • +
      匹配前一个字符1或者无限次
    res1 = re.search('ab+', 'abbbcd').group()  # abbb
    res2 = re.search('ab+', 'aabbbcd').group()  # abbb
    • ?
      匹配前一个字符0或者1次
    res1 = re.search('ab?', 'abbbcd').group()  # ab
    res2 = re.search('ab?', 'aabbbcd').group()  # a
    • {m}
      匹配前一个字符m次
    res1 = re.search('ab{2}', 'abbbcd').group()  # abb
    • {m,n}
      匹配前一个字符m到n次
    res2 = re.search('ab{1,3}', 'aabbbcd').group()  # abbb
    • *?,+?,??,{m,n}?
      变成非贪婪匹配
    res2 = re.search('ab{1,3}?', 'aabbbcd').group()  # ab

    边界匹配

    • ^,\A
    res1 = re.search('^aab\d+', 'aab112').group()
    #  aab112
    • $,\Z
    res1 = re.search('[a-z]+112$', 'aab112').group()
    #  aab112
    • \b
      没搞懂
    • \B

    逻辑分组

    • |
      或,多组从左到右依次匹配,单个字符
      先尝试匹配左边的,成功则跳过右边,失败则匹配右边
    res1 = re.search('(a|b|A)lex', 'Alex').group()
    #  Alex
    res1 = re.search('(a|b|A)lex', 'alex1234Alex').group()
    #  alex
    • (...)
      分组
    res1 = re.search('(ab){2}\d+', 'abab123df').group()
    #  abab123
    res1 = re.search('(ab).*(df)', 'abab123cdf').groups()
    #  ('ab', 'df')
    • (?P<name>...)
      分组,加上别名
    res1 = re.search('(?P<privince>\d{4})(?P<city>\d{4})', '12345678').groupdict()
    #  {'privince': '1234', 'city': '5678'}

    参考资料
    1476661-20190507143548717-1117440114.png

    转载于:https://www.cnblogs.com/qiuyicheng/p/10749795.html

    展开全文
  • re模块中的函数,找到匹配项的时候,返回MatchObject对象。这些对象包括匹配模式的子字符串的信息。它们还包含录哪个模式匹配了子字符串那部分的信息,这些部分就是不同的“组”。组就是放在圆括号内的子模式。组...
  • 用于参数flags二、匹配公式1、模式1)开头结尾2)一个字符or数字3)数量、贪婪与非贪婪4)其它2、正则表达式实例1)字符类2)特殊字符类三、函数/方法1、re.compile(pattern[, flags])2、re.matchre.searchre....
  • Python 之 re模块 正则表达式

    千次阅读 2016-08-02 00:10:53
    正则对象(re object) search(): 最常用的,返回一个匹配对象(Match Object) match():类似search,但仅仅从文字的开始进行匹配; split():分割一个string,返回字符串的数组 findall():找到所有的匹配字符串的...
  • 正则练习 re_my

    2018-08-15 22:17:25
    import re # 1. 以 h 开头 # 2. 以h开头后面跟着一个字符 # 3. 以h开头后面跟着任意数量的数字 # 4. 以3结尾 # 5. 以h开头,以3结尾,中间只有一个字符串 # 6. 以h开头,以3结尾,中间可以存在任意数量的字符串 ''...
  • 这篇文章主要介绍了python re模块匹配贪婪和非贪婪模式详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 ...>>> r=re.match(.+(\d+-\d+-\d+-\d+),
  • res=re.match('[A-Z][a-z]*','Harry') #第一个匹配大写,第二个匹配小写 print(res.group()) #+ 匹配前一个字符出现一次或者无限次,至少出现一次 res1=re.match('[a-zA-Z]+','jy') #该语句表示大小写都匹配 print...
  • python re的贪婪和非贪婪匹配

    万次阅读 2013-12-23 12:02:57
    正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;非贪婪则相反,总是尝试匹配尽可能少的字符...>>> r=re.match(".+(\d+-\d+
  • import sys import re WORD_RE = re.compile(r'\w+') index = {} with open(sys.argv[1], encoding='utf-8') as fp: for line_no, line in enumerate(fp, 1): for match in WORD_RE.finditer(line):
  • 匹配多个字符的相关格式 示例1:* ...ret = re.match("[A-Z][a-z]*","Mm") ret.group() ret = re.match("[A-Z][a-z]*","Aabcdef") ret.group() 运行结果...
  • 匹配多个字符的相关格式 示例1:* 需求:匹配出,一个字符串第一个字母为大小字符,...ret = re.match("[A-Z][a-z]*","Mm") ret.group() ret = re.match("[A-Z][a-z]*","Aabcdef") ret.group() 运行结果: 示例2...
  • Python里数量词(*+?)默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;非贪婪的则相反,总是尝试匹配尽可能少的字符。...print(re.match(r"^(\d+)(0*)$","8848000").gro
  • 表示数量(匹配多个字符) 【示例】匹配手机号码 ...v=re.match(pattern,s) print(v)   如果要匹配电话号码,需要形如“\d\d\d\d\d\d\d\d\d\d\d”这样的正则表达式。其中表现 了 11 次“\d”,表
  • 使用re:import refilenames = ['file1.jpg','file2.jpg','file3.jpg','file4.jpg','fileA.jpg',]### We'll match on a general pattern of any character before a number + '.jpg'### Then, we'll look for a file...
  • 找到数组I整数可分的最小数量【难度:2级】: 答案1: from fractions import gcd import re ... l = [e for e in arr if not re.match('(None)|([+-]?\d+)', str(e))] if len(l) == 1: return 'Th...
  • Python 正则表达式

    2020-04-18 23:14:19
    文章目录正则表达式正则表达式相关注解re.match()re.search()re.search和re.match的区别re.sub()re.compile()re.findall()re.finditer()re.split()示例:查找文件名前缀 正则表达式 正则表达式相关注解 (1)数量...
  • 正则匹配 :以h开头以3结尾 ...# match_res = re.match('h1234',line) # # if match_res: # print('匹配成功') # else: # print('匹配失败') # 以h开头后面跟着任意数量的字符 # line = 'h123eeee' # li...
  • 正则表达式

    2018-03-08 23:18:00
    result =re.match 如果这一步匹配到数据的话 可以使用group方法提取数据result.group() 2、匹配对象Match Object 具有group方法 用来返回字符串的匹配部分 3、表示字符: 4、表示数量 {m,n}最少出现m次 ...
  • python正则表达式

    2017-08-30 10:11:30
    python正则表达式 正则表达式基础 1 简单介绍 2 数量词的贪婪模式与非贪婪模式 3 反斜杠的困扰 4 匹配模式 re模块 1 开始使用re 2 Match 3 Pattern
  • 正则表达式相关注解(1)数量词的贪婪模式与非贪婪模式(2)反斜杠问题4.Python Re 模块(1)re.match(pattern, string[, flags])(2)re.search(pattern, string[, flags])(3)re.split(pattern, string[, ...
  • 贪婪模式 总是尽可能多的匹配,默认就是贪婪 非贪婪模式 相反,尽...v = re.match(r'abc(\d+)','abc123') # 贪婪模式 print(v.group(1)) v = re.match(r'abc(\d+?)','abc123') # 非贪婪模式 print(v.group(1)) ...
  • 文章目录一、正则表达式1、规范表示2、数量表示3、逻辑运算符二、Python正则表达式模块 - re三、字符串清洗1、清洗字符串中的数字2、清除网址中的垃圾字符三、字符...re.match #从头匹配 re.search #全局匹配第一个符合
  • 贪婪模式 python中数量词默认是贪婪的,总是尝试匹配尽可能多的字符。 非贪婪模式 与贪婪相反,总是尝试匹配尽可能少的...v1 = re.match(r'(.+)(\d*-\d*)', '1327-48949') # 贪婪模式 v2 = re.match(r'(.+?)(\d*-\d...
  • python练习2020/08/05

    2020-08-05 23:17:45
    if re.match('day',source): print('可以匹配到') else: print('没有匹配到') 习题2: 找出一个字符串中是否有连续的5个数字 import re re.search(r'[a-z]{5}','adfdfd34354').group() 习题4:统计一个文件中单词...
  • 学习正则(一)

    2019-10-05 16:21:05
    1、元字符:在正则中有特殊含义的字符。 2、量词:表示数量的词。 3、范围匹配:规定正则在指定的字符列表中进行匹配,每次只会匹配字符列表中...console.log(str.match(re)); var re2= /a[bdf]c/g;//匹配abc...
  • 正则表达式 Regular Expression定义模式语言匹配字符的操作符匹配数量的操作符匹配集合的操作符匹配位置的操作符常用实例常用函数re.search(pattern,string,flags=0)re.match(pattern, string, flags=0) 定义 自己的...
  • python学习014_正则

    2019-08-08 18:54:11
    文章目录正则引入案例1Python正则表达式基础re.match单字符匹配规则数量匹配规则表示边界匹配分组re.searchre.findallre.finditer 正则 正则表达式,又称规则表达式**。**(英语:Regular Expression,在代码中常...

空空如也

空空如也

1 2 3 4
收藏数 80
精华内容 32
关键字:

matchre数量