精华内容
下载资源
问答
  • 一个正则表达式要如何书写才能同时匹配这两个数字呢?简单的字符表达式当然无法完成了,这个时候我们就可以定义一个字符集合(字符类)来进行匹配。这就是分组匹配
  • 本文给大家详细介绍了JavaScript正则表达式的分组匹配的概念以及具体的使用方法并附上了相关示例,有需要的小伙伴可以参考下。
  • 主要介绍了详解JavaScript正则表达式之分组匹配及反向引用 的相关资料,需要的朋友可以参考下
  • 正则表达式匹配分组等其他的情况 字符 功能 | 匹配左右任意一个表达式 (ab) 将括号中字符作为一个分组,可以和|一起使用(ab|cd)表示... 引用别名为name分组匹配到的字符串 案例演示1: impo...

    正则表达式匹配分组等其他的情况

    字符功能
    |匹配左右任意一个表达式
    (ab)将括号中字符作为一个分组,可以和|一起使用(ab|cd)表示匹配括号内分组中的一个
    \num引用分组num匹配到的字符串
    (?P<name>)分组起别名
    (?P=name)引用别名为name分组匹配到的字符串

     案例演示1:

    import  re
    
    pattern = '^M?M?M?(CM|CD|D?C?C?C?)$'
    str = 'MMDCC'
    s= re.search(pattern,str)
    print(s.group())  #MMDCC,将()做一个分组,然后|表示匹配其左右任意一个表达式
    
    str1 ='MCMCD'
    s1 = re.search(pattern,str1)
    print(s1.group()) #匹配失败,因为CM和DC在|的左右,只可以匹配其中之一
    

    案例演示2:

    import  re
    
    pattern ='^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'
    s1 = re.search(pattern, 'MDLV')
    print(s1.group())  #MDLV.第一个M匹配,第一个括号匹配D.第二个括号L.第三个括号V.
    
    s2 = re.search(pattern,'')
    print(s2.group()) #匹配成功空串.第一个M可以为空,第一个括号DC可以为空,后面同理
    
    s3 = re.search(pattern, 'MMDCLXVI')
    print(s3.group())  #MMDCLXVI
    
    s4 = re.search(pattern, 'MMMDCCCLXXXVIII')
    print(s4.group()) #MMMDCCCLXXXVIII
    
    s5 = re.search(pattern,'I')
    print(s5.group()) #I 前面为空,最后一个括号匹配I

    案例3:group的使用补充 

    import  re
    '''
    group()将匹配的结果直接以字符串的形式返回
    groups()将正则匹配中的分组()匹配结果以元组形式返回
    group(1) 将groups分组匹配的结果分别取出,就是第一个()的内容,同理group(2)就是第二个()内容
    '''
    phonePattern =  re.compile(r'^\D*(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$')
    s1 =  phonePattern.search('(800)5551212 ext.1234')
    
    #注意下面group(),groups(),group(1)的结果
    print(s1.group()) #(800)5551212 ext.1234
    print(s1.groups())  #('800', '555', '1212', '1234')
    print(s1.group(1)) #800
    

    案例4:\num分组匹配的使用,好多人没搞明白 

    import re
    #目标中列表里匹配出<html><h1>www.bai.com</h1></html>
    
    labels = ["<html><h1>www.bai.com</h1></html>", "<html><h1>www.sina.cn</h2></html>"]
    
    for label in labels:
        ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", label)
        #这里所谓的\2指的是第二个分组匹配的结果,因为一个()表示一个分组,也就是正则里的第二个括号
        # 所以\2代表的分组就是第二个(\w*)匹配的结果,这里也就是h1.
    
        # ret1 = re.match(r"<(\w*)><(\d*)>.*</\2></\1>", label)
        #注意如果这里讲第二个()换成(\d*),就会匹配失败
        if ret:
            print("%s 是符合要求的标签" % ret.group())
        else:
            print("%s 不符合要求" % label)
    '''
    <html><h1>www.bai.com</h1></html> 是符合要求的标签
    <html><h1>www.sina.cn</h2></html> 不符合要求
    '''

    总结:

    ^ 匹配字符串开始位置。
    • $ 匹配字符串结束位置。
    • \b 匹配一个单词边界。
    • \d 匹配一个数字。
    • \D 匹配一个任意的非数字字符。
    • x? 匹配可选的 x 字符。换句话说,就是 0 个或者 1 个 x 字符。
    • x* 匹配 0 个或更多的 x。
    • x+ 匹配 1 个或者更多 x。
    • x{n,m} 匹配 n 到 m 个 x,至少 n 个,不能超过 m 个。
    • (a|b|c) 匹配单独的任意一个 a 或者 b 或者 c。
    • (x) 这是一个组,它会记忆它匹配到的字符串。你可以用
    re.search 返回的匹配对象的 groups()函数来获取到匹配的值

    python正则匹配的贪婪和非贪婪

    Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;

    非贪婪则相反,总是尝试匹配尽可能少的字符。

    在"*","?","+","{m,n}"后面加上?,使贪婪变成非贪婪。

    >>> s="This is a number 234-235-22-423"
    >>> r=re.match(".+(\d+-\d+-\d+-\d+)",s)
    >>> r.group(1)
    '4-235-22-423'
    >>> r=re.match(".+?(\d+-\d+-\d+-\d+)",s)
    >>> r.group(1)
    '234-235-22-423'
    >>>
    

    正则表达式模式中使用到通配字,那它在从左到右的顺序求值时,会尽量“抓取”满足匹配最长字符串,在我们上面的例子里面,“.+”会从字符串的启始处抓取满足模式的最长字符,其中包括我们想得到的第一个整型字段的中的大部分,“\d+”只需一位字符就可以匹配,所以它匹配了数字“4”,而“.+”则匹配了从字符串起始到这个第一位数字4之前的所有字符。

    解决方式:非贪婪操作符“?”,这个操作符可以用在"*","+","?"的后面,要求正则匹配的越少越好。

    >>> re.match(r"aa(\d+)","aa2343ddd").group(1)
    '2343'
    >>> re.match(r"aa(\d+?)","aa2343ddd").group(1)
    '2'
    >>> re.match(r"aa(\d+)ddd","aa2343ddd").group(1) 
    '2343'
    >>> re.match(r"aa(\d+?)ddd","aa2343ddd").group(1)
    '2343'
    >>>

    统一声明:关于原创博客内容,可能会有部分内容参考自互联网,如有原创链接会声明引用;如找不到原创链接,在此声明如有侵权请联系删除哈。关于转载博客,如有原创链接会声明;如找不到原创链接,在此声明如有侵权请联系删除哈。 

    展开全文
  • 【Java】正则表达式分组匹配

    千次阅读 2019-05-20 23:07:17
    分组匹配: 正则表达式分组: 如果想匹配3个数字,正则表达式可以用如下写法: \d{3} 以上代码使用重复量词可以匹配3位数字。 但是在实际应用中,往往需要重复多个字符,例如我想重复ab两个字符,使用以下代码就不...

    分组匹配:

    正则表达式分组:
    如果想匹配3个数字,正则表达式可以用如下写法:

    \d{3}
    

    以上代码使用重复量词可以匹配3位数字。
    但是在实际应用中,往往需要重复多个字符,例如我想重复ab两个字符,使用以下代码就不合适了,代码如下:

    ab{3}
    

    以上正则表达式只能够重复3次b。
    为了实现重复多个字符可以使用小括号来指定子表达式或者说分组来实现此功能,例如:

    (ab){3}
    

    上面的正则就可以重复ab了。
    所谓的分组就是使用小括号将一些项包括起来,使其成为独立的逻辑域,那么就可以像处理一个独立单元一样去处理小括号的内容。

    下面看一段代码实例:

    (\d{1,3}\.){3}\d{1,3}
    

    上面是一个简单的ip匹配正则表达式。由小括号包裹的内容会被作为一个独立的逻辑域进行操作。
    分组的作用:
    在正则表达式中,分组具有举足轻重的作用,下面就简单对它的功能做一下简单的介绍。

           /**
    		 * 分组匹配
    		 * 
    		 */
    		@Test
    		public void test6() {
    			String regex = "(%)(.*?)(%)";//()表示分组
    			String str = "%akhscgaijgs% %dgqydfwydf% %aswdd%";
    			
    			System.out.println(str.replaceAll(regex, "$2"));//$表示组,$2表示组2
    			System.out.println(str.replaceAll(regex, "$1aaaa$3"));
    		}
    		@Test
    		public void test7() {
    			Pattern pattern = Pattern.compile("(%)(.*?)(%)");//模式对象
    			//pattern是模式对象,此方法会将匹配到的东西遍历出来
    			String str = "%akhscgaijgs% %dgqydfwydf% %aswdd%";
    			Matcher m = pattern.matcher(str);
    			int i = 0;
    			while(m.find()) {//find为从匹配的对象里面去查找
    				i++;
    				System.out.println(m.group(1) + " aaa "+ m.group(3) + " startIndex"+m.start()+",endIndex:" + m.end());
    				//此处为输入的为所替换的组号,,而将其他组号替换出来
    			}
    		}
    
    展开全文
  • 本博文源于python基础,主要探讨re模块的分组匹配与匹配对象使用。

    本博文源于python基础,主要探讨re模块的分组匹配与匹配对象使用。

    正则概述

    正则的原理是《自动机》这门课讲的内容。
    1986年图灵奖–约翰·霍普克洛夫特和罗伯特·陶尔扬简介这门课的创始人就是他们,有兴趣点开看看。之前也做过所有图灵奖大佬合集,也可以看看。正则的原理,我也做了博文。因此,再学正则就会发现很亲近。无非就这些元字符的排列组合。python外加封装罢了。
    在这里插入图片描述
    大家在学习下面的时候,不要慌乱。谨记一条口诀:先看标题讲了啥,再看内容有没有跟之前学过相似。类比学习。

    re模块

    re是python正则模块标准库

    正则匹配搜索函数

    这里有两个函数作正则匹配,一个是match,另一个是search。当博主去百度搜索的时候,发现match是匹配搜个,search是从全体字符串寻找匹配。而findall是一个查找所有并返回列表,而前面两个是返回对象。我们先看原型

    re.match(pattern,string[,flags])
    re.search(pattern,string[,flags])
    re.findall(pattern,string[,flags])
    
    • pattern 正则匹配模式
    • string 要进行匹配的字符串
    • flags 可选参数,进行匹配的标志.(flags细讲)
    flag选项意义
    re.I忽略大小写
    re.L根据本地设置而更改\w.\W.\b.\B.\s,以及\S的匹配内容
    re.M多行匹配模式
    re.S使"."元字符也匹配换行符
    re.U匹配Unicode字符
    re.X忽略pattern中的空格,并且可以使用“#”

    这里演示一下match和search、findall匹配。打开ipython演示哟!

    In [11]: s = 'Life can be good'
    
    In [12]: import re
    
    In [13]: print(re.match('life',s,re.I))
    <re.Match object; span=(0, 4), match='Life'>
    
    In [14]: print(re.match('life',s))
    None
    In [15]: print(re.search('be',s))
    <re.Match object; span=(9, 11), match='be'>
    
    In [16]: print(re.findall('[a-z]{1,3}',s))
    ['ife', 'can', 'be', 'goo', 'd']
    
    In [17]:          
    

    sub()与subn()函数

    这两个函数多了一个n,就当作是附加次数的意思

    • sub返回替换后的字符串
    • subn返回一个元组,元组包括替换后的字符串和一共替换的次数
    re.sub(pattern,repl,string[,count])
    re.subn(pattern,repl,string[,count])
    
    • pattern 正规表达式模式
    • repl 要替换成的内容
    • string 进行内容替换的字符串
    • count 可选参数,最大替换次数
    
    In [18]: import re
    
    In [19]: s = 'Life can be bad'
    
    In [20]: print(re.sub('bad|be','good',s,1))
    Life can good bad
    
    In [21]: s
    Out[21]: 'Life can be bad'
    
    In [22]: print(re.subn('bad|be','good',s,1))
    ('Life can good bad', 1)
    
    In [23]:
    

    split()函数

    想想python本身就有分割。然后正则再来一个分割。其实re.split()函数用于分割字符串,它返回分割后的字符串列表。

    re.split(pattern,string[,maxsplit = 0])
    
    • pattern 正则表达式模式
    • string 要分割的字符串
    • maxsplit 可选参数,最大分割次数
    In [23]: s = 'I2like3py4rex5'
    
    In [24]: re.split('\d',s)
    Out[24]: ['I', 'like', 'py', 'rex', '']
    
    In [25]:
    

    正则表达式对象

    讲到这里大家可以松口气了,这里不过是给我们广大程序员一个方便的。它将正则实例化方便我们多次使用。所以官方叫做预编译,总所周知编译完成为可执行程序它的内容就被固定下来,这里也是同理。让我们一起体验一下吧!

    compile(pattern[,flags])
    
    • pattern 正则表达式匹配模式
    • flags 可选参数,编译标志

    预编译完毕,是要执行的,执行的有几个属性跟上面讲过的一致,下面就一起带过吧

    match()

    跟上面的match相同,要匹配的字符串位于开始

    match(string[,pos[,endpos]])
    
    • string 要进行匹配的字符串
    • pos 可选参数,进行匹配的起始位置
    • endpos 可选参数,进行匹配的结束位置

    search()

    跟上面的search类似,全体字符串中查询

    search(string[,pos[,endpos]])
    
    • string 要进行匹配的字符串
    • pos 可选参数,进行匹配的起始位置
    • endpos 可选参数,进行匹配的结束位置

    findall()

    findall(string[,pos[,endpos]])
    

    跟上面的findall类似

    sub()和subn()

    跟上面的sub与subn同理

    sub(repl,string[,count=0])
    subn(repl,string[,count=0])
    
    • repl 要替换成的内容
    • string 进行内容替换的字符串
    • count 可选参数,最大替换次数

    split()

    与上面的split类似

    split(string[,maxsplit=0])
    
    • string 要分割的字符串
    • maxsplit 可选参数,最大分割次数

    这里我们将简单测试一二

    例子:给定一个字符串,以数字切割
    • I1like2python3
    
    In [26]: import re
    
    In [27]: rex = re.compile('\d')
    
    In [28]: s = 'I1like2python3'
    
    In [29]: rex.split(s)
    Out[29]: ['I', 'like', 'python', '']
    

    分组匹配与匹配对象使用

    知道了前面那么多,为什么还要学习这个?因为有一些字符串往往有规律,分成组后更容易操作
    例如:

    • 邮箱的规则
    • 邮编的规则
    • 号码的规则等等

    分组基础

    python以一对圆括号"()"来表示位于其中的内容属于一个分组

    例子:演示用正则分割号码的区号和本地号码

    
    In [41]: import re
    
    In [42]: s = 'Phone No. 010-87654321'
    
    In [43]: r = re.compile(r'(\d+)-(\d+)')
    
    In [44]: m = r.search(s)
    
    In [45]: m
    Out[45]: <re.Match object; span=(10, 22), match='010-87654321'>
    
    In [46]: m.groups()
    Out[46]: ('010', '87654321')
    
    In [47]:
    
    

    分组扩展

    小朋友头上是否有很多问号?确实!分组扩展(?<组名>)遍地都是问号

    扩展语法意义
    (?Lmsux)设置匹配标志,可以是左边字符以及它们的组合,其含义与编译标志相同
    (?:…)匹配但不捕获该匹配的子表达式
    (?P=name)表示在此之前的名为name的组
    (?#…)表示注释
    (?=…)用于正则表达式之后,表示如果"=“后的内容在字符串中出现则匹配,但不返回”="后的内容
    (?!..)用于正则表达式之后,表示如果"!“后的内容在字符串中出现则匹配,但不返回”!"后的内容
    (?<=…)用于正则表达式之前,与(?=…)含义相同
    (?<!..)用于正则表达式之前,与(?!..)含义相同

    匹配对象与组的使用

    三个函数可以查看最后的结果

    group([group1,...])# 返回字符串
    groups([default]) # 返回元组
    groupdict([default]) # 返回字典
    

    例子:匹配所有包含字母“a”的单词

    使用group,groups,groupdict输出他们

    In [84]: import re
    
    In [85]: s = '''Life can be dreams,
        ...: Life can be great thoughts;
        ...: Life can mean a person,
        ...: Sitting in a court.'''
    
    In [86]: r = re.compile('\\b(?P<first>\w+)a(\w+)\\b')
    
    In [87]: m = r.search(s)
    
    In [88]: m.groupdict()
    Out[88]: {'first': 'c'}
    
    In [89]: m.groups()
    Out[89]: ('c', 'n')
    
    In [90]: m.group(1)
    Out[90]: 'c'
    
    In [91]:
    
    

    匹配对象与索引使用

    一共有三个原型

    start([groupid=0])
    end([groupid=0])
    span(groupid=0)
    
    • groupid为可选参数,即分组编号,如果不传,返回整个字符串索引
    • start()返回字符串起始索引
    • end()返回字符结束位置索引
    • span()则以元组返回以上的两者

    例子:匹配所有包含a的单词,用索引进行输出

    In [95]: r = re.compile('\\b(?P<first>\w+)a(\w+)\\b')
    
    In [96]: m = r.search(s,9)
    
    In [97]: m.start()
    Out[97]: 12
    
    In [98]: m.start(1)
    Out[98]: 12
    
    In [99]: m.start(2)
    Out[99]: 16
    
    In [100]: m.end(1)
    Out[100]: 15
    
    In [101]: m.end()
    Out[101]: 18
    
    In [102]: m.span()
    Out[102]: (12, 18)
    
    In [103]: m.span(2)
    Out[103]: (16, 18)
    
    In [104]:                                                                                                               
    
    展开全文
  • Python正则表达式之嵌套分组匹配

    千次阅读 2019-06-17 17:31:14
    嵌套分组匹配 一般的分组匹配 target1 = '021-12345' pattern = r'^(\d{3})-(\d{3,8})$' m = re.match(pattern,target1) print(m.groups()) # 返回提取的子串 print(m.group(0)) # 永远是目标字符串本身 print(m....

    嵌套分组匹配

    1. 一般的分组匹配
    target1 = '021-12345'
    pattern = r'^(\d{3})-(\d{3,8})$'
    m = re.match(pattern,target1)
    print(m.groups()) # 返回提取的子串
    print(m.group(0)) # 永远是目标字符串本身
    print(m.group(1)) # 提取的第一个子串
    print(m.group(2)) # 提取的第二个子串
    

    输出:

    ('021', '12345')
    021-12345
    021
    12345
    
    1. 嵌套分组
    target = 'tree/combined 010-12345'
    pattern = r'(([^/]*)(/.*)?)[\s]+((\d{3})\-(\d{3,8})$)' # [^]:匹配除了里面列出的任一字符
    m = re.match(pattern,target)
    print(m.groups())
    print(m.group(1))   # 首先匹配最外层的()
    print(m.group(2))   # 然后依次匹配里层的()
    print(m.group(3))
    # 这里匹配到的是 010-12345 
    print(m.group(4))   # 同理,从左往右依次匹配,若()里面还有分组就递归下去匹配分组
    print(m.group(5))
    print(m.group(6))
    

    输出:

    ('tree/combined', 'tree', '/combined', '010-12345', '010', '12345')
    tree/combined
    tree
    /combined
    010-12345
    010
    12345
    
    结论

    嵌套分组匹配时,从左往右依次匹配(),若()里面还有(),则递归进行分组匹配,递归匹配完之后,再继续从左往右匹配()。

    展开全文
  • 语法 元字符 (pattern) 作用用于反复匹配分组 属性 $1~$9 如果它 (们)存在用于得到对应分组匹配到的子串 \1 或 $1 用于匹配第一个分组中的内容 \2 或 $2 用于匹配第一个分组中的内容 . \9 或 $9 用于匹配第一个...
  • 正则表达式'(?P...)' 分组匹配

    千次阅读 2018-10-30 17:20:28
    P...)' 分组匹配 例:身份证 1102231990xxxxxxxx import re s = '1102231990xxxxxxxx' res = re.search('(?P&lt;province&gt;\d{3})(?P&lt;city&gt;\d{3})(?P&lt;born_year&gt;\d{3})',s...
  • python正则表达式,分组匹配

    千次阅读 2019-03-21 09:05:21
    # 正则表达式是一个特殊的字符序列,一个字符串是否与我们设定的这样的字符序列匹配; # 快速检索文本,实现一些替换文本的操作 a = 'Java|node|Javascript|C++|node' # print(a.index('node')) # print('node' in...
  • js正则里的分组匹配

    千次阅读 2019-02-25 12:08:55
    参考博文 ...var str = 'kid is kid' var reg = /(\w{3}) is \1/ reg.test(str) == true 这里的正则表达式里的'\1'相当于前面的 (\w{3}) =&gt;即一个分组;...表示匹配的第一个分组; var str = 'aaaab...
  • import ( ...// 使用命名分组,一次匹配多个值 re := regexp.MustCompile(`(?P<fname>\w+):+(?P<mod>[1-9]*):*(?P<strlen>[0-9]*)`) match := re.FindStringSubmatch(str) groupNames :.
  • 正则表达式,分组匹配示例

    千次阅读 2016-01-14 15:49:52
    假设有如下几行文本: ... 如果匹配出第1条和第3条,那么可以使用以下的正则表达式: "((xxx)|(zzz))".*  其中,最外层的括号是不能省略的,即不能写成:   "(xxx)|(zzz)".*     然后,在匹配到的结
  • 请问如何运用vb6.0中文平台的编程技术实现文本输入的界面的分类分组匹配和反白显示的功能?
  • 使用findall匹配的时候如果正则表达式中使用了分组,返回值为列表形式,并且往往和想要得到的结果相差许多 例如: 查看源码: 返回字符串中所有非重叠匹配的列表。 如果模式中存在一个或多个捕获组,则返回组列表; ...
  • 关于正则表达式替换,前面我写过一个应用: python2代码搬运到python3要改很多print? 试试用pyCharm的正则表达式替换 &nbsp;...上面一行的匹配模式print (\S*)中,括号括起的部分匹配到的内...
  • 本文主要讲解javascript 的正则表达式中的分组匹配与前瞻匹配的,需要对正则的有基本认识,本人一直对两种匹配模棱不清。所以在这里总结一下,如有不对,还望大神指点。 1.分组匹配:  1.1捕获性分组匹配 ()  2.2...
  • Python之匹配分组

    2019-12-05 21:00:24
    匹配分组 语法 | : 匹配左右任意一个表达式 (ab) : 将括号中的字符...p=name) : 引用别名为name分组匹配到的字符串 | 示例 # 匹配0-100之间所有的数字 import re pattern = r'[0-9]?\d$|100$' v1 = re.ma...
  • 正则表达式匹配分组操作示例 匹配分组 | 匹配左右任意一个表达式 ( ) 将括号中的字符作为一个分组 \num 引用分组num匹配到的字符 (?P<...引用别名为name的分组匹配到的字符 ...
  • 这里的代码示例我用python实现一下: ...调用group(0)返回的是原字符串,group(1)返回的是分组匹配的第一个,group(2)返回的是分组匹配的是第二个,一次类推。 示例:我们简单匹配一下邮件地...
  • 正则表达式匹配分组(6) 1. 匹配分组相关正则表达式 代码 功能 ...引用别名为name分组匹配到的字符串 示例1:| 需求:在列表中[“apple”, “banana”, “orange”, “pear”],匹配ap...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 187,222
精华内容 74,888
关键字:

分组匹配