精华内容
下载资源
问答
  • 正则表达式匹配边界
    2021-03-08 13:54:48

    接下来学习正则表达式的边界表示,边界表示就是在写正则表达式的时候,限制匹配的字符串的开始和结束边界。

    字符 描述
    ^ 匹配字符串开头
    $ 匹配字符串结尾
    \b 匹配一个单词的边界
    \B 匹配非单词边界
    注意:边界字符只用于描述边界信息,不能用于字符的匹配。

    示例:完善之前课时中关于手机号码匹配的示例,在匹配超过11位的手机号,或者11位的手机号后边还有其他字符的情况,正则表达式也能够匹配成功,这种情况是不允许的。这种情况就需要限制手机号的结尾。

    #使用$限制匹配的字符串以11位数字组成,结尾不能添加其他字符
    rs = re.match("1[3578]\d{9}$","13612345678") 
    print(rs.group()) #匹配正确的手机号
    #手机号末尾添加字符串将匹配失败
    rs = re.match("1[3578]\d{9}$","13612345678abc")#匹配失败
    print(type(rs)) #空类型
    

    运行结果:

    13612345678
    <class ‘NoneType’>
    (使用match方法进行正则匹配“^”匹配开头不是很明显,因为match本身就是从左向右顺序匹配的)

    示例:邮箱匹配

    #邮箱地址以3到10个单词字符开始,以@163.com结束
    rs = re.match("\w{3,10}@163.com$","hello_123@163.com")
    print(rs)
    rs = re.match("\w{3,10}@163.com$","he@163.com")
    print(rs)
    rs = re.match("\w{3,10}@163.com$","hello_12345645@163.com")
    print(rs)
    rs = re.match("\w{3,10}@163.com$","hello_123@163.comhaha")
    print(rs)
    

    运行结果:

    <_sre.SRE_Match object; span=(0, 17), match=‘hello_123@163.com’>
    None
    None
    None
    问题1:随意用一个字母代替邮箱中的“.”也会匹配成功

    rs = re.match("\w{3,10}@163.com$","hello_123@163hcom")
    print("匹配结果:%s"%rs)
    

    运行结果:

    匹配结果:<_sre.SRE_Match object; span=(0, 17), match=‘hello_123@163hcom’>
    原因是:在正则表达式中“.”有特殊的含义,表示除\n之外的任意字符

    解决办法:使用转义字符\ 标识“.”是普通字符“.”

    rs = re.match("\w{3,10}@163\.com$","hello_123@163.com")
    print("匹配结果1:%s"%rs)
    rs = re.match("\w{3,10}@163\.com$","hello_123@163hcom")
    print("匹配结果2:%s"%rs)
    

    运行结果:

    匹配结果1:<_sre.SRE_Match object; span=(0, 17), match=‘hello_123@163.com’>
    匹配结果2:None

    更多相关内容
  • $ 匹配结尾字符 定义整个字符串必须以指定字符串结尾 import re print(re.match('.*d$','2testaabcd')) #字符串必须以d结尾 a=re.match('.*d$','2testaabcd') print(a.group()) print(re.match('.*c$','2...

    $ 匹配结尾字符

    定义整个字符串必须以指定字符串结尾

    import re
    print(re.match('.*d$','2testaabcd')) #字符串必须以d结尾
    a=re.match('.*d$','2testaabcd')
    print(a.group())
    print(re.match('.*c$','2testaabcd'))  #字符串不是以c结尾,返回none
    b=re.match('.*c$','2testaabcd')
    #注:rP:$,原教程第二个没有添加$,RP自己发现了
    c=re.match('.*c$','2testaabc')
    print(c.group())
    
    
    

    输出:

    <re.Match object; span=(0, 10), match='2testaabcd'>
    2testaabcd
    None
    2testaabc

    ^ 匹配开头字符

    定义整个字符串必须以指定字符开头

    import re
    print(re.match('^2','2stoooabatestas')) #规定必须以2开头,否则none
    a=re.match('^2','2stoooabatestas')
    print(a.group())
    print(re.match('^2s','2stoooabatestas')) #必须以2s开头
    b=re.match('^2s','2stoooabatestas')
    print(b.group())
    c=re.match('^32s','32stoooabatestas')
    print(re.match('^2','32stoooabatestas'))
    print(c.group())
    

    输出:

    <re.Match object; span=(0, 1), match='2'>
    2
    <re.Match object; span=(0, 2), match='2s'>
    2s
    None
    32s

    \b 匹配一个单词的边界

    \b:表示字母数字与非字母数字的边界,非字母数字与字母数字的边界。即下面ve的右边不能有字母和数字

    import re
    print(re.match(r'.*ve\b','ve.2testaabcd'))  #因为在python中\代表转义,所以前面加上r消除转义
    a=re.match(r'.*ve\b','ve.2testaabcd')
    print(a.group())
    print(re.match(r'.*ve\b','ve2testaabcd'))
    print(re.match(r'.*ve\b','vep2testaabcd'))#rp:遇到字母或数字不显示
    

     输出:

    <re.Match object; span=(0, 2), match='ve'>
    ve
    None
    None

    \B 匹配非单词边界

    import re
    print(re.match(r'.*ve\B','2testaavebcdve'))  #ve的右边需要有字母或者数字
    a=re.match(r'.*ve\B','2testaavebcdve')
    print(a.group())
    print(re.match(r'.*ve\B','2testaave3bcdve'))
    print(re.match(r'.*ve\B','2testaave.3bcdve'))#点
    print(re.match(r'.*ve\B','2testaave 3bcdve'))#空格
    print(re.match(r'.*ve\B','2testaave*3bcdve'))#星号

     输出:

    <re.Match object; span=(0, 9), match='2testaave'>
    2testaave
    <re.Match object; span=(0, 9), match='2testaave'>
    None
    None
    None

    展开全文
  • 目录正则表达式1. 正则标记1.1 字符1.2 字符... 真题5.1 压缩算法5.2 音节判断5.3 正则表达式匹配(剑指Offer 面试题19) 正则表达式 概述:描述了一种字符串匹配的模式,用来检查一个串是否含有某个子串、将匹配的子串替
  • python正则表达式匹配

    千次阅读 2021-08-25 19:59:15
    1. 正则表达式—特殊表达式含义 1.1 普通字符集 1) \w 匹配字母数字及下划线 2) \W 匹配非字母数字及下划线 3) \s 匹配任意空白字符,等价于 [\t\n\r\f]. 4) \S 匹配任意非空白字符 5) \d 匹配任意数字,等价于 [0-9...

    1. 正则表达式—特殊表达式含义

    1.1 普通字符集

    1)    \w              	匹配字母数字及下划线
    2)    \W              	匹配非字母数字及下划线
    3)    \s                匹配任意空白字符,等价于 [\t\n\r\f].
    4)    \S               匹配任意非空白字符
    5)    \d               匹配任意数字,等价于 [0-9]
    6)    \D               匹配任意非数字
    7)    \1...\9           匹配第n个分组的内容。
    8)    [a-zA-Z0-9]    	匹配任何字母及数字
    

    1.2 数量字符集

    用在字符或分组符(…)之后,默认贪婪匹配,如果想抑制贪婪匹配,需在数量字符后加?,例如:\w+?

    1) .    	匹配任意字符,除了换行符,当re.DOTALL标记被指定时,可以匹配包括换行符的任意字符
    2)  *       匹配前一个字符0次1次或多次
    3)  +       匹配前一个字符1次或多次
    4)  ?       匹配前一个字符0次或1次
    5)  {m}     匹配前一个字符m次
    6)  {m,n}   匹配前一个字符m到n次
    7)  {m,}    匹配前一个字符至少m次
    8)  {,n}    匹配前一个字符0到n次,最多n次
    

    1.3 边界匹配符

    1)  ^      匹配字符串开头,如果是多行则匹配每一行的开头
    2)  [^]      在[...]中,^表示否定,如非字母[^a-zA-Z],非数字[^0-9]
    3)  $      	匹配字符串或一行的结尾,如果是多行匹配模式,则每一行的结尾
    4)  \A      仅匹配字符串的开始,同^
    5)  \b      匹配一个单词的边界,也就是指单词和空格间的位置
    6)  \B      等价于[^\b]表示匹配非单词边界
    7)  \Z      匹配字符串结束,如果是存在换行,只匹配到换行前的结束字符串。
    8)  \z      匹配字符串结束
    

    1.4 逻辑匹配符

    1)  |(或)
        匹配 | 左右任意一种正则表达式,如果左边表达式匹配上,匹配结束,不再匹配右边的正则表达式,该符号一般放在()中使用,如果没在圆括号中则它的范围是整个正则表达式
    2)  分组 (...)
        后向引用,用()括起来的正则表达式将被作为一个分组,从正则表达式的左边依次算起,有多少个左括号'(',就有 多少个分组,分组的编码从1依次加1,无论是括号中嵌套括号,并且分组表达式作为一个整体,后可接数量词。
    3)  \<number>
        引用分组匹配到的分组编号为<number>的字符串 如:\1...\9
    4)  (?P<name>...)
        命名分组,除了默认的分组编号外再指定一个别名分组
        注意:P是大写
    5)  (?P=name)
        引用别名为name的分组匹配,这个是在正则表达式中引用,表示匹配重复的字符串,也可以使用编号引用。
        注意:P是大写
    

    1.5 特殊匹配符

    1)  (?imx)     	正则表达式包含三种可选标志:i, m, 或 x 。只影响括号中的区域。
    2)  (?-imx)     	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
    3)  (?:...)      	匹配到的括号内字符串不作为分组
    4)  (?!pattern)   	前向否定断言语法,表示否定开头, 只能用在正则表达式的开头,pattern是匹配模式,它后面的内容需要不匹配 该正则表达式才匹配成功
    5)  (?<!pattern)  	后向否定断言语法,表示否定结尾,前面的内容需要不匹配该pattern模式才匹配成功
    6)  (?=pattern)  	前向肯定断言语法. 需要匹配pattren模式才能匹配成功,表示肯定前面的字符内容
    7)  (?<=pattern)  	后向肯定断言语法, 需要匹配pattern模式才能匹配成功,表示肯定后面的字符内容
    8)  (?#...)     	后面的内容将被作为注释而忽略
    

    2. 例子

    # coding=utf-8
    import re
    # 1. 写一个正则表达式,使其能同时识别下面所有的字符串:'bat','bit', 'but', 'hat', 'hit', 'hut'
    
    s ="bat ,bit ,but ,hat ,hit ,hut"
    print re.findall(r'[bh][aiu]t',s)
    
    # 2.匹配由单个空格分隔的任意单词对,也就是姓和名
    
    s = "Han meimei, Li lei, Zhan san, Li si"
    print re.findall(r'([A-Za-z]+) ([A-Za-z]+)',s)
    
    # 3. 匹配由单个逗号和单个空白符分隔的任何单词和单个字母,如姓氏的首字母
    
    s = "yu, Guan  bei, Liu  fei, Zhang"
    print re.findall(r'([a-zA-Z]+),\s([a-zA-Z])',s)
    
    # 4.匹配所有的有效的Python标识符集合
    
    s = "_hello , python_1 , 2world , Pra_ni , @dfa_ , ewq* "
    print re.findall(r'\b[a-zA-z_][\w]*(?!=\W) ',s)
    
    # 5. 根据美国街道地址格式,匹配街道地址。美国接到地址使用如下格式:1180 Bordeaux Drive。使你的正则表达式足够灵活,以支持多单词的街道名称,如3120 De la Cruz Boulevard
    
    s = """street 1: 1180  Bordeaux Drive,"
        street 1: 3120 De la Cruz Boulevard"""
    print re.search(r'\d+( +[a-zA-Z]+)+',s).group()
    
    # 6. 匹配以“www”起始且以“.com”结尾的简单Web域名:例如,http://www.yahoo.com ,也支持其他域名,如.edu .net等
    
    s = "http://www.yahoo.com        www.foothill.edu"
    print re.search(r'w{3}\.[a-zA-Z]+\.(com|edu|net)',s).group()
    
    # 7. 匹配所有能够表示Python整数的字符串集
    
    s = '520a1    20L 0  156   -8 -10a  A58'
    ite = re.finditer(r'-?\d+',s)
    for i in ite: print i.group(),
    
    # 8. 匹配所有能够表示Python长整数的字符串集
    
    s = '520a    20L 0  156   -8L  A58'
    ite = re.finditer(r'-?\d+L',s)
    for i in ite: print i.group(),
    
    # 9. 匹配所有能够表示Python浮点数的字符串集
    
    s = '80.2  fds2.1  0.003'
    print re.findall(r'\d+\.\d+',s)
    
    # 10. 表示所有能够表示Python复数的字符串集
    
    s = '12j  fds -4j  5-2j fdsa'
    print re.findall(r'\d*-?\d+j',s)
    
    # 11、匹配一行文字中的所有开头的字母内容
    
    s="Now, let's take a closer look at some iconic moments from the show's stage made by Chinese Angels."
    print re.findall(r'\b\w',s)
    
    # 12、匹配一行文字中的所有开头的数字内容
    
    s="Now, let's take a closer look at some iconic moments from the show's stage made by Chinese Angels."
    print re.findall(r'\b\d',s)
    
    # 13、匹配一行文字中的所有开头的数字内容或字母内容
    
    s = "577fsda3f you12daf f1s32dafffff"
    print re.findall(r'\b\d+|\b[A-Za-z]+',s)
    
    # 14、 只匹配包含字母和数字的行
    
    s = "nihao fsadf \n789! 3asfd 1\nfds12df e4 4564"
    print re.findall(r'^([a-zA-Z\d ]+)$',s,re.M)
    
    # 15、提取每行中完整的年月日和时间字段
    
    s="""time 1988-01-01 17:20:10 fsadf 2018-02-02 02:29:01"""
    print re.findall(r'[12]\d{3}\-[01]\d\-[0123]\d\s*[012]\d\:[012345]\d\:[012345]\d',s)
    
    # 16、将每行中的电子邮件地址替换为你自己的电子邮件地址
    
    s="""xss@qq.com, 465465@163.com, ppp@sina.com
        s121f@139.com, soifsdfj@134.com
        pfsadir423@123.com"""
    print re.sub(r'\w+?\@\w+?\.com','zeke@qq.com',s)
    
    # 17、匹配\home关键字:
    
    s ="fdsar \home   \homeer"
    print re.findall(r'\\home',s)
    
    展开全文
  • 介绍  在实际项目中有个功能的实现需要解析一些特定模式的字符串。而在已有的代码库中,在已实现的部分功能中,都是使用检测特定的字符,使用这种方法的缺点是: 逻辑上很容易出错 ...而我自己在正则表达式
  • Java中的正则表达式匹配过程

    正则表达式:定义字符串的模式,用来对字符串进行搜索、编辑或处理文本。

    目前的正则表达式引擎大体上可分为不同的两类:DFA和NFA,而NFA又基本上可以分为传统型NFA和POSIX NFA。

    DFA Deterministic finite automaton 确定型有穷自动机

    NFA Non-deterministic finite automaton 非确定型有穷自动机

    Java使用的是传统型NFA引擎。

    下面是Java正则表达式的语法字符:

    \

    将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如, n匹配字符 n。\n 匹配换行符。序列 \\\\ 匹配 \\ ,\\( 匹配 (。

    ^

    匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与"\n"或"\r"之后的位置匹配。

    $

    匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$ 还会与"\n"或"\r"之前的位置匹配。

    *

    零次或多次匹配前面的字符或子表达式。例如,zo* 匹配"z"和"zoo"。* 等效于 {0,}。

    +

    一次或多次匹配前面的字符或子表达式。例如,"zo+"与"zo"和"zoo"匹配,但与"z"不匹配。+ 等效于 {1,}。

    ?

    零次或一次匹配前面的字符或子表达式。例如,"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。

    {n}

    是非负整数。正好匹配 n 次。例如,"o{2}"与"Bob"中的"o"不匹配,但与"food"中的两个"o"匹配。

    {n,}

    是非负整数。至少匹配 次。例如,"o{2,}"不匹配"Bob"中的"o",而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*"。

    {n,m}

    m 和 n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。例如,"o{1,3}"匹配"fooooood"中的头三个 o。'o{0,1}' 等效于 'o?'。注意:您不能将空格插入逗号和数字之间。

    ?

    当此字符紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串,而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如,在字符串"oooo"中,"o+?"只匹配单个"o",而"o+"匹配所有"o"。

    .

    匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式。

    (pattern)

    匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( ),请使用"\("或者"\)"。

    (?:pattern)

    匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如,'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。

    (?=pattern)

    执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows",但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

    (?!pattern)

    执行反向预测先行搜索的子表达式,该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows",但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

    x|y

    匹配 x 或 y。例如,'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。

    [xyz]

    字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a"。

    [^xyz]

    反向字符集。匹配未包含的任何字符。例如,"[^abc]"匹配"plain"中"p","l","i","n"。

    [a-z]

    字符范围。匹配指定范围内的任何字符。例如,"[a-z]"匹配"a"到"z"范围内的任何小写字母。

    [^a-z]

    反向范围字符。匹配不在指定的范围内的任何字符。例如,"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。

    \b

    匹配一个字边界,即字与空格间的位置。例如,"er\b"匹配"never"中的"er",但不匹配"verb"中的"er"。

    \B

    非字边界匹配。"er\B"匹配"verb"中的"er",但不匹配"never"中的"er"。

    \cx

    匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样,则假定 c 就是"c"字符本身。

    \d

    数字字符匹配。等效于 [0-9]。

    \D

    非数字字符匹配。等效于 [^0-9]。

    \f

    换页符匹配。等效于 \x0c 和 \cL。

    \n

    换行符匹配。等效于 \x0a 和 \cJ。

    \r

    匹配一个回车符。等效于 \x0d 和 \cM。

    \s

    匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。

    \S

    匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。

    \t

    制表符匹配。与 \x09 和 \cI 等效。

    \v

    垂直制表符匹配。与 \x0b 和 \cK 等效。

    \w

    匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效。

    \W

    与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。

    \xn

    匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如,"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。

    \num

    匹配 num,此处的 num 是一个正整数。到捕获匹配的反向引用。例如,"(.)\1"匹配两个连续的相同字符。

    \n

    标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么 n 是反向引用。否则,如果 n 是八进制数 (0-7),那么 n 是八进制转义码。

    \nm

    标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式,那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获,则 n 是反向引用,后面跟有字符 m。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 和 m 是八进制数字 (0-7)。

    \nml

    当 n 是八进制数 (0-3),m 和 l 是八进制数 (0-7) 时,匹配八进制转义码 nml

    \un

    匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9 匹配版权符号 (©)。

            正则的匹配过程,通常情况下都是由一个子表达式(可能为一个普通字符、元字符或元字符序列组成)取得控制权,从字符串的某一位置开始尝试匹配,一个子表达式开始尝试匹配的位置,是从前一子表达匹配成功的结束位置开始的。如果匹配到字符串某一位置时整个表达式匹配失败,那么引擎会使正则向前传动,整个表达式从下一位开始重新尝试匹配,依此类推,直到报告匹配成功或尝试到最后一个位置后报告匹配失败。

    正则表达式简单的匹配过程:

     代码为pattern为正则表达式对content进行匹配

    (1) 基础匹配过程

        public static void main(String[] args) {
            String content = "abc";
    
            String pattern = "abc";
            System.out.println(content.matches(pattern));
        }

    匹配过程:       

            首先由字符“a”取得控制权,由“a”来匹配“a”,匹配成功,控制权交给字符“b”;由于“a”已被“a”匹配,所以“b”从位置1开始尝试匹配,由“b”来匹配“b”,匹配成功,控制权交给“c”;由“c”来匹配“c”,匹配成功放回true。

    (2)贪婪模式

        public static void main(String[] args) {
            String content = "abc";
    
            String pattern = "ab?c";
            System.out.println(content.matches(pattern));
        }

            量词“?”属于匹配优先量词,在可匹配可不匹配时,会先选择尝试匹配,只有这种选择会使整个表达式无法匹配成功时,才会尝试让出匹配到的内容。这里的量词“?”是用来修饰字符“b”的,所以“b?”是一个整体。

    匹配过程:

            首先由字符“a”取得控制权,由“a”来匹配“a”,匹配成功,控制权交给字符“b?”;由于“?”是匹配优先量词,所以会先尝试进行匹配,由“b?”来匹配“b”,匹配成功,控制权交给“c”,同时记录一个备选状态;由“c”来匹配“c”,匹配成功。记录的备选状态丢弃。

        public static void main(String[] args) {
            String content = "abd";
    
            String pattern = "ab?c";
            System.out.println(content.matches(pattern));
        }

     

    匹配过程:

            首先由字符“a”取得控制权,,由“a”来匹配“a”,匹配成功,控制权交给字符“b?”;先尝试进行匹配,由“b?”来匹配“b”,同时记录一个备选状态,匹配成功,控制权交给“c”;由“c”来匹配“d”,匹配失败,此时进行回溯,找到记录的备选状态,“b?”忽略匹配,即“b?”不匹配“b”,让出控制权,把控制权交给“c”;由“c”来匹配“b”,匹配失败。此时第一轮匹配尝试失败。

    正则引擎使正则向前传动,由位置1开始尝试匹配,由“a”来匹配“b”,匹配失败,没有备选状态,第二轮匹配尝试失败。

    继续向前传动,直到所有尝试匹配失败,匹配结束。此时报告整个表达式匹配失败。

    (3)非贪婪模式 

        public static void main(String[] args) {
            String content = "abc";
    
            String pattern = "ab??c";
            System.out.println(content.matches(pattern));
        }

            量词“??”属于忽略优先量词,在可匹配可不匹配时,会先选择不匹配,只有这种选择会使整个表达式无法匹配成功时,才会尝试进行匹配。这里的量词“??”是用来修饰字符“b”的,所以“b??”是一个整体。

    匹配过程:

            首先由字符“a”取得控制权,由“a”来匹配“a”,匹配成功,控制权交给字符“b??”;先尝试忽略匹配,即“b??”不进行匹配,同时记录一个备选状态,控制权交给“c”;由“c”来匹配“b”,匹配失败,此时进行回溯,找到记录的备选状态,“b??”尝试匹配,即“b??”来匹配“b”,匹配成功,把控制权交给“c”;由“c”来匹配“c”,匹配成功。

    (4)零宽度匹配过程

            所谓零宽断言,简单来说就是匹配一个位置,这个位置满足某个正则,但是不纳入匹配结果的,所以叫“零宽”,而且这个位置的前面或后面需要满足某种正则。

        public static void main(String[] args) {
            String content = "abc";
    
            String pattern = "^(?=[a-z])[a-z0-9]+$";
            System.out.println(content.matches(pattern));
        }

            元字符“^”和“$”匹配的只是位置,顺序环视“(?=[a-z])”只进行匹配,并不占有字符,也不将匹配的内容保存到最终的匹配结果,所以都是零宽度的。

            这个正则的意义就是匹配由字母或数字组成的,第一个字符是字母的字符串。

    匹配过程:

            首先由元字符“^”取得控制权,从开始位置开始匹配,匹配成功,控制权交给顺序环视“(?=[a-z])”;

    “(?=[a-z])”要求它所在位置右侧必须是字母才能匹配成功,零宽度的子表达式之间是不互斥的,即同一个位置可以同时由多个零宽度子表达式匹配,所以它也是从开始位置尝试进行匹配,开始位置的右侧是字符“a”,符合要求,匹配成功,控制权交给“[a-z0-9]+”;

    因为“(?=[a-z])”只进行匹配,并不将匹配到的内容保存到最后结果,并且“(?=[a-z])”匹配成功的位置是开始位置,所以“[a-z0-9]+”也是从开始位置开始尝试匹配的,“[a-z0-9]+”首先尝试匹配“a”,匹配成功,继续尝试匹配,可以成功匹配接下来的“b”和“c”,此时右侧已没有字符,这时会把控制权交给“$”;“$”成功匹配结束符,匹配成功。

    展开全文
  • -或- 对正则表达式功能字符的还原,如”*”匹配它前面元字符0次或多次,/a*/将匹配a,aa,aaa,加了”\”后,/a\*/将只匹配”a*”。 ^ 匹配一个输入或一行的开头,/^a/匹配”an A”,而不匹配”An a” $ 匹配一个输入...
  • 正则表达式边界符1

    2021-10-10 21:16:51
    3.2、边界符 提示字符所处的位置,主要是有俩个字符。 ^ 表示匹配行首的文本(以谁开始) $ 表示匹配行尾的文本(以谁结尾) 3.4、量词符: 量词符用来设定某个模式出现的次数。 量词 说明 * 重复零次或更多...
  • 重播在字符流中查找与正则表达式匹配的序列。 可以匹配的正则表达式只有基本的,只有*+?()| 支持。 没有. 对于任何字符,没有字符子类,没有重复次数限制。 也没有像\n这样的转义字符或特殊字符。 所以到目前为止这...
  • 在Google自定义引擎中搜索文本中的关键字,然后对其进行分析以使其与正则表达式匹配。 在用于分析OSINT的渗透测试的“信息收集”阶段可用。 获得“原始”内容进行处理的站点:github.com,gist.github.com,...
  • oracle 正则表达式 匹配

    千次阅读 2021-04-30 10:42:13
    正则表达式中常用到的元数据(metacharacter)如下:^ 匹配字符串的开头位置。$ 匹配支付传的结尾位置。*匹配该字符前面的一个字符0次,1次或者多次出现。例如52*oracle 可以匹配 5oracle,52oracle,522o...
  • 一、单词边界正则表达式中单词边界是用\b表示,是指单词和非单词之间的位置,并非指字符在正则表达式中除了单词边界和非单词边界表示位置外,行首^和行尾$也是表示位置要了解单词边界首先要知道单词和边界的定义,...
  • 我登陆这里是因为这个问题的标题很宽泛,我一直...在探索问题时,我想出了一个系统,使您可以通过将四个在分隔符上匹配的更简单的子表达式以及顺序中的年,月和日字段的有效范围排列在一起,来构建正则表达式 您需要...
  • 中文正则(正则表达式匹配指定中文)

    千次阅读 2021-04-21 07:26:11
    \u4E00-\u9FA5能验证中文,但是包含中文符号 我只想要中文(不要'‘;... }}这个可以了,推荐你一个正则表达式工具,填入这个\w{1,},不.using system.text.regularexpressions; public static ...
  • 正则表达式匹配模式,要么匹配字符,要么匹配位置。本章讲讲正则匹配位置的汇总1、什么是位置?位置是相邻字符之间的位置。比如,下图中箭头所指的地方:image.png2、如何匹配位置呢?在ES5中,共有6个锚字符:**^...
  • 正则表达式匹配数字范围

    千次阅读 2021-04-10 15:04:21
    正则表达式匹配数字范围,匹配单个数字的方式很简单,[0-9]是[0123456789]的简写形式,可以用来匹配任何一个数字。如果要匹配 0 到 255 中的所有数字,该怎么办呢?表达式[0-255]并不能达到目的。下表所示为数字元...
  • 使用正则表达式,用法如下: ## 总结 ## ^ 匹配字符串的开始。 ## $ 匹配字符串的结尾。 ## \b 匹配一个单词的边界。 ## \d 匹配任意数字。 ## \D 匹配任意非数字字符。 ## x? 匹配一个可选的 x 字符 (换言之,它...
  • .(句点)匹配除了换行之外的所有一个字符, .*(点-星)匹配除了换行外的所有字符>>>>>> r=re.compile(r'.*')>>> r.search('How are you\nFine thank you and you\nI am fine too').group()'How are you'>>>这个例子...
  • python实现正则表达式匹配

    千次阅读 2020-12-28 21:24:58
    给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。 . 匹配任意单个字符 * 匹配零个或多个前面的那一个元素 所谓匹配,是要涵盖整个字符串 s的,而不是部分字符串。 ...
  • 经常我们会遇到想找出不包含某个字符串的文本,程序员最容易想到的是在正则表达式里使用,^(hede)来过滤”hede”字串,但这种写法是错误的。...事实上,说正则表达式里不支持逆向匹配并不是百分之百的正确。就像...
  • Python正则表达式匹配整个单词

    千次阅读 2020-11-30 11:44:22
    守候你守候我我认为,通过给出的答案,OP所期望...给出的绳子是,a = "this is a sample"“任择议定书”接着说,我想匹配整个单词-例如匹配"hi"应该回来False自"hi"不是一个词.。据我所知,引用的是搜索标记,"hi"正...
  • 正则表达式匹配一个单词

    千次阅读 2021-02-10 11:39:06
    比如我想匹配result,但是文中有许多results,这时就需要用到\b来表示单词的前后边界
  • 我们都知道,Python中边界匹配用的是’\b’,那么如下的正则应该能匹配出‘tag’字符串。 re.findall(r'\btag\b', '带tag#tag内容#') 实际上呢,这是不行的。原因是,Python的正则匹配,使用了和C语言一样的规则,...
  • 正则表达式的大致匹配过程是:依次拿出表达式和文本中的字符比较,如果每一个字符都能匹配,则匹配成功;一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界,这个过程会稍微有一些不同,但也是很好理解...
  • Java 使用正则表达式匹配淘口令

    千次阅读 2019-07-17 10:16:27
    项目中被正则表达式的反斜线问题坑了几次了,今天恰好用到正则表达式匹配,又遇到饭斜线的处理,记录一下。先对比其他语言和 Java 语言中反斜线,最后再给出淘口令匹配的案例。
  • 正则表达式——匹配

    2021-08-25 21:19:59
    正则表达式简介 1 正则表达式的作用: 用于对字符串进行操作 2 正则的功能(都是对字符串进行的操作): 匹配 替换 提取 二 正则表达式的使用 1 创建方式 const reg = new RegExp("abc"); // 或 const ...
  • 例如/b/相当于字符b,通过在b前面加一个反斜杠,即为//,则该字符变成特殊字符,表示匹配一个单词的分界线。对于几个字符,通常说明是特殊的,符号指出其后的字符不是特殊的,而应按字面解释2、字符*表示匹配的字符...
  • Python爬虫之使用正则表达式匹配网页内容

    千次阅读 多人点赞 2020-01-03 11:22:57
    Python爬虫,除了使用大家广为使用的scrapy架构外,还有很多包能够实现一些简单的爬虫,如...正则表达式是一种描述字符串排列的一种语法规则,通过该规则可以在一个大字符串中匹配出满足规则的子字符串。简单来...
  • 正则表达式的模式匹配

    千次阅读 2022-03-14 17:41:47
    JavaScript 的 RegExp 类表示正则表达式,String 和 RegExp 都定义了方法,后者使用正则表达式进行强大的模式匹配和文本检索与替换功能。 正则表达式的定义 正则表达式可以使用 RegExp() 构造函数来创建 RegExp 对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,365
精华内容 21,746
关键字:

正则表达式匹配边界