精华内容
下载资源
问答
  • 所谓贪婪匹配就是匹配重复字符是尽可能多的匹配,比如: "aaaaa".match(/a+/); //["aaaaa", index: 0, input: "aaaaa"] 非贪婪匹配就是尽可能少的匹配,用法就是在量词后面加上一个“?”,比如: "aaaaa".match...
  • 主要介绍了js正则表达式最长匹配(贪婪匹配)和最短匹配(懒惰匹配)用法,结合实例形式分析了贪婪匹配与懒惰匹配的具体用法与相关注意事项,需要的朋友可以参考下
  • 在CMS开发中,经常会有类似这样的需求:  提问——回答模式,经典的例子是百度提问。  提问者提出问题,由其他人回答,其他人可以是用户,也可以是服务商。  在这个模式中,如何充分利用历史数据是关键的...
  • 主要介绍了js正则表达式惰性匹配和贪婪匹配用法,结合实例形式详细分析了正则表达式的基本概念以及惰性匹配和贪婪匹配的使用方法,需要的朋友可以参考下
  • 正则表达式默认是贪婪匹配,即每个规则都尽可能多的匹配 非贪婪匹配的每个规则具体匹配到哪里,可以总结为 尽可能少的匹配 匹配到下一个规则为止 来看例子 package RegularExpression; import java.util.regex....

    正则表达式默认是贪婪匹配,即每个规则都尽可能多的匹配

    非贪婪匹配的每个规则具体匹配到哪里,可以总结为

    1. 尽可能少的匹配
    2. 匹配到下一个规则为止

    来看例子

    package RegularExpression;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class demo5 {
        public static void main(String[] args) {
            //正则表达式的贪婪匹配
            Pattern pattern = Pattern.compile("(\\d+)(1*)");
            Matcher matcher = pattern.matcher("1213111");
            if (matcher.matches()) {
                System.out.println("group1=" + matcher.group(1));
                System.out.println("group2=" + matcher.group(2));
            }
        }
    }
    
    

    这里是贪婪匹配,所以虽然我将正则表达式分为了两组,希望用(\d+)匹配1213,而(1*)匹配剩下的3个1
    但是结果是
    在这里插入图片描述
    (\d+)这个规则实际上会将整个字符串的所有数字都匹配了,不会留给(1*)这个规则,所以group(2)里面什么都没有

    这就是贪婪匹配,即尽可能多的匹配,只要字符串中的内容满足这个规则,就会全部匹配上

    那么现在,在规则的后面加上一个?,这表示非贪婪匹配

    package RegularExpression;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class demo5 {
        public static void main(String[] args) {
            //正则表达式的非贪婪匹配
            Pattern pattern = Pattern.compile("(\\d+?)(1*)");
            Matcher matcher = pattern.matcher("1213111");
            if (matcher.matches()) {
                System.out.println("group1=" + matcher.group(1));
                System.out.println("group2=" + matcher.group(2));
            }
        }
    }
    
    

    结果为
    在这里插入图片描述
    这里就可以发现,按照我们一开始希望的那样分组了

    这里问题来了,\d是可以匹配0到9的数字字符的,那么为什么非贪婪匹配状态下的\d+就能这么准的匹配到1213截止,而后面的不匹配呢

    这里就是非贪婪匹配的特点
    尽可能少的匹配,以及匹配到下一个规则为止
    这里后面的111都可以交给1*规则来匹配,不需要自己来匹配,所以\d+到此为止,如果我们修改一下代码

    package RegularExpression;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class demo5 {
        public static void main(String[] args) {
            //正则表达式的非贪婪匹配
            Pattern pattern = Pattern.compile("(\\d+?)(0*)");
            Matcher matcher = pattern.matcher("1213111");
            if (matcher.matches()) {
                System.out.println("group1=" + matcher.group(1));
                System.out.println("group2=" + matcher.group(2));
            }
        }
    }
    
    

    (1*)被换成了(0*),结果是
    在这里插入图片描述
    如果后面的规则不能匹配剩下的字符串,那么非贪婪匹配的规则也依旧后往后匹配

    这里再举一个例子

    package RegularExpression;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    public class demo5 {
        public static void main(String[] args) {
            Pattern pattern = Pattern.compile("(\\d+?)(0*?)(0*)");
            Matcher matcher = pattern.matcher("1230000");
            if (matcher.matches()) {
                System.out.println("group1=" + matcher.group(1));
                System.out.println("group2=" + matcher.group(2));
                System.out.println("group3=" + matcher.group(3));
            }
        }
    }
    

    在这里插入图片描述
    会发现(0*?)没有匹配任何字符,这是因为修饰符 * 可以匹配任意个字符,包括0个字符。非贪婪的规则,能不匹配就不匹配,而且后面也有能匹配剩余字符串的规则。所以这里group(2)里面的内容是空。

    展开全文
  • 贪婪匹配: +,?,*,{n},{n,},{n,m} 匹配时,如果遇到上述标识符,代表是贪婪匹配,会尽可能多的去匹配内容. 下面是贪婪匹配的示例: content = 'Xiaoshuaib has 102 bananas' #贪婪匹配: res1 = re.findall('^...

    贪婪匹配:

    +?*{n}{n,}{n,m}

    匹配时,如果遇到上述标识符,代表是贪婪匹配,会尽可能多的去匹配内容.

    下面是贪婪匹配的示例:

    content = 'Xiaoshuaib has 102 bananas'
    
    #贪婪匹配:
    res1 = re.findall('^Xi.*(\d+).*$',content) 
    #直到遇到最后一个符合条件的(/d)为止,这时遇到最后一个符合条件的元素是2 -> 2
    ----------------------out----------------------
    res1: ['2'] 
    

    非贪婪匹配:

    尽量匹配少的内容,一旦碰到第一个符合条件的元素就不再继续向后匹配

    标识符:
    +???*?{n}?{n,}?{n,m}?
    (在贪婪标识符后面加?)

    res2 = re.findall('^Xi.*?(\d+).*$',content) 
    #非贪婪匹配,遇到第一个符合条件的元素就放弃匹配,第一个符合条件的元素是1 -> 102
    -------------------out------------------
    res2: ['102']
    
    展开全文
  • 例: 匹配输入串A: 101000100 贪婪匹配: 使用 1.*1 将会匹配到1010001 非贪婪匹配: 使用 1.?1 将会匹配到101

    例:
    匹配输入串A: 1001000100
    贪婪匹配:
    使用 1.*1 将会匹配到10010001
    非贪婪匹配:
    使用 1.*?1 将会匹配到1001

    主要区别在于是否加?当?紧随任何其他限定符之后时,匹配模式是"非贪心的"。“非贪心的"模式匹配搜索到的、尽可能短的字符串,而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。
    * 含义为零次或多次匹配前面的字符或子表达式。例如,zo* 匹配"z"和"zoo”。
    . 字符匹配除"\r\n"之外的任何单个字符

    package org.example;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class ZhengZe {
        public static void main(String[] args) throws Exception{
    
            String regEx = "1.*?1";
            String s = "100010000000000001";
            Pattern pat = Pattern.compile(regEx);
            Matcher mat = pat.matcher(s);
            if(mat.find()){
                System.out.println(mat.group(0));
            }
        }
    }
    
    展开全文
  • 贪婪匹配和非贪婪匹配 1.贪婪匹配 2.非贪婪匹配 正则表达式的分组 猫眼电影TOP100信息提取 1.需求分析 2.代码分析 3.编写程序 正则表达式:re模块 re模块有两种方式实现正则匹配 方式一: lists=re.find...

    目录

    正则表达式:re模块

    元字符

    正则表达式如何匹配任意字符:re.S

    贪婪匹配和非贪婪匹配

    1.贪婪匹配

    2.非贪婪匹配

    正则表达式的分组

    猫眼电影TOP100信息提取

    1.需求分析

    2.代码分析 

    3.编写程序


    正则表达式:re模块

    re模块有两种方式实现正则匹配

    方式一:

    lists=re.findall("he","hello world")

    方式二:

    pattern=re.complie("he")

    lists=pattern.findall("hello world")

    这两种方法都可以正则匹配字符,只是第二种方式提前定义了正则表达式,可以复用,所以推荐使用第二种方式

     

    元字符

    正则表达式常用的元字符如下:

    .匹配任意一个字符,除了\n
    *匹配0个或多个的字符串
    +匹配1个或多个的字符串
    匹配0个或1个,为非贪婪方式
    [a, b , c]匹配 ‘a’ 或 ‘b’ 或 ‘c’
    \s匹配 任何 空白字符, 相当于[\t\n\r\f]
    \S匹配 任何 非空白字符, 相当于[^\t\n\r\f]

     

    正则表达式如何匹配任意字符:re.S

    通常来说,如果我们要匹配任意字符,可以这样写(方式一):

    pattern=re.complie("[\s\S]")

    lists=pattern.findall("hello\nworld")

    这样写可以匹配到\n,看下面这种写法,这个写法并不会匹配\n这个换行符。一个页面有非常多的换行符,所以这么写时不合理的。

    pattern=re.complie(".*")

    lists=pattern.findall("hello\nworld")

    那么我们可以使用re.S,如下,re.S代表允许'. '匹配'\n'(方式二,推荐):

    pattern=re.complie(".*",re.S)

    lists=pattern.findall("hello\nworld")

     

    贪婪匹配和非贪婪匹配

    1.贪婪匹配

    在整个表达式匹配成功的情况下,尽可能的多匹配*或 + 或 ?。

    表达方式:.* 或 .+ 或 .?

    2.非贪婪匹配

    在整个表达式匹配成功的情况下,尽可能的少匹配* 或 + 或 ?。

    表达方式:.*? 或 .?? 或 .+?

     

    贪婪匹配和非贪婪匹配到底有什么含义能,看下面的例子:

    编写这么一段代码,我们预期的结果是得到几个集合,集合里有两个对象,<div><p>今天天气不错</p></div>和<div><p>太阳很舒服</p></div>

    import re
    
    str="""
    <div><p>今天天气不错</p></div>
    <div><p>太阳很舒服</p></div>
    """
    
    pattern=re.compile("<div><p>.*</p></div>",re.S)
    lists=pattern.findall(str)
    
    print(lists)

    但是结果却成了一个对象,这是因为在贪婪匹配模式下,由于‘.’会匹配任意字符(它会认为</p></div>也是任意字符),所以它会匹配到最后一个以‘</p></div>’结尾的字符串。

    再看下面的一段代码,稍一看似乎没什么区别,眼睛尖的是能发现区别的,在.*后面加了一个?号,刚才说了这是非贪婪表达式方式,而非贪婪匹配的匹配模式是匹配最近的以</p></div>结尾的字符串(仅在这个案例中),这样的匹配模式正好符合我们的预期结果。

    import re
    
    str="""
    <div><p>今天天气不错</p></div>
    <div><p>太阳很舒服</p></div>
    """
    
    pattern=re.compile("<div><p>.*?</p></div>",re.S)
    lists=pattern.findall(str)
    
    print(lists)

    结果:

     

    总结:在正则表达式中,绝大数情况会使用非贪婪匹配,非常好理解,我们需要的内容是一个装满了成功匹配的对象集合,而不是一个连在一起的对象集合(而且在多数情况下返回的结果总是会与你预想的结果有区别)。

     

    正则表达式的分组

    还是上面那个案例,我们刚才得到的结果如下图,我们仅需要<div></div>中间的内容该如何处理,这就需要用的正则表达式分组。

    正则表达式分组是指在完整的的模式中定义子模式,将每个用圆括号中的子模式作为结果提取出来

    实际运用非常简单,还是上面的代码,我们只需要在.*?包在括号里即可,如下: 

    import re
    
    str="""
    <div><p>今天天气不错</p></div>
    <div><p>太阳很舒服</p></div>
    """
    
    pattern=re.compile('<div><p>(.*?)</p></div>',re.S)
    lists=pattern.findall(str)

    做完上面的案例后,我们在具体来聊一下正则表达式的分组,请看下面3个案例:

    import re
    
    
    str='A B C D'
    pattern2=re.compile("\w+\s+\w+")
    lists2=pattern2.findall(str)
    
    pattern3=re.compile("(\w+)\s+\w+")
    lists3=pattern3.findall(str)
    
    pattern4=re.compile("(\w+)\s+(\w+)")
    lists4=pattern4.findall(str)
    
    print(lists2)
    print(lists3)
    print(lists4)
    

    先看第一组正则表达式:re.compile("\w+\s+\w+"),我们知道\w匹配任意字母和数字,+号匹配一个或多个,我们定义的str='A B C D',按照匹配规则,\w+将匹配一串连续的字符,而这里的字符用空格隔开了,所以只会匹配一个字符。\s+匹配任何空白字符,最后的\w+匹配一个字符。那么总结下来就是这样的匹配规则:字符 空格 字符。结果也是如此。

    再看第二组正则表达式:re.compile("(\w+)\s+\w+"),与第一组的区别在与第一个\w+加了括号,从结果上区别就是只匹配到了一个字符。我们在上面的案例中讲了正则表达式的分组,这里的括号就是给\w+做分组,然它成为子模式。在子模式下只取出子模式的匹配内容作为结果,这里的\w+的匹配结果是A,所以输出A。

    第三组:re.compile("(\w+)\s+(\w+)")。第三组有两个括号,代表有两个子模式。两个子模式会以元组的方式输出。

     

    总结:

    1.正则表达式的分组是通过加()来实现的

    2.如果只想取匹配结果的某一段内容,为这一段内容的匹配模式加上()

    3.有两个()将会以元组的方式进行输出

     

    猫眼电影TOP100信息提取

     

    1.需求分析

    猫眼电影TOP100榜单URL:https://maoyan.com/board/4?offset=0

    页面详情如下,我们要提取的信息有电影名称、主演、上移时间和评分。

    因为是top100,每页显示10个,总计10页。分析URL得到第一页为https://maoyan.com/board/4?offset=0,第二页为https://maoyan.com/board/4?offset=10。

    所以页码格式为offset=(page-1)*10

     

    2.代码分析 

    提取信息的关键在与写对正则表达式,如图所示,我们要提取的信息有划红线的部分。

     

    经过整理后得出的信息如下,我们要以这一串内容写一段正则表达式。首先我们将需要提取的字符打上分组符号()。要注意的是电影名有两处显示,我们选择title里的;评分是分为两段显示的,我们都要打上标记。切忌不要把他写成一行,目前这一段格式包含了\n换行符,并且每一个位置都是精确的,不易改动。

    <div class="movie-item-info">
            <p class="name"><a href="/films/1203" title="霸王别姬" data-act="boarditem-click" data-val="{movieId:1203}">霸王别姬</a></p>
            <p class="star">
                    主演:张国荣,张丰毅,巩俐
            </p>
    <p class="releasetime">上映时间:1993-07-26</p>    </div>
        <div class="movie-item-number score-num">
    <p class="score"><i class="integer">9.</i><i class="fraction">5</i>

    打完之后如下,现在这一段正则表达式仅可以匹配霸王别姬这一段内容,我们要想办法让他匹配所有。 

    <div class="movie-item-info">
            <p class="name"><a href="/films/1203" title="(.*?)" data-act="boarditem-click" data-val="{movieId:1203}">霸王别姬</a></p>
            <p class="star">
                    (.*?)
            </p>
    <p class="releasetime">(.*?)</p>    </div>
        <div class="movie-item-number score-num">
    <p class="score"><i class="integer">(.*?)</i><i class="fraction">(.*?)</i>

    我们将多余的部分用.*?代替。得到如下格式。刚才说了,因为有换行符的存在,所以在换行出也要打上.*?

    <div class="movie-item-info">
            .*?title="(.*?)".*?
            <p class="star">
                    (.*?)
            </p>.*?
    <p class="releasetime">(.*?)</p>.*?
    <i class="integer">(.*?)</i><i class="fraction">(.*?)</i>

    最终经过整理后,得到下面内容。这里不要留空行,挤压成一段字符串。

    <div class="board-item-main">.*?title="(.*?)".*?<p class="star">(.*?)</p>.*?<p class="releasetime">(.*?)</p>.*?<i class="integer">(.*?)</i><i class="fraction">(.*?)</i>

     

    3.编写程序

    1.定义一个类

    2.初始化类,定义url,headers,正则匹配表达式

    3.定义方法:get_html()用于获取页面,注意转码

    4.定义方法:run(),作为类的入口函数,提示输出页面。显示结果需要进一步处理,去除空格符

    from urllib import request
    import re
    
    class Maoyan_spider(object):
    
        def __init__(self):
            self.url="https://maoyan.com/board/4?offset={}"
            self.headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36"}
            self.pattern=re.compile('<div class="board-item-main">.*?title="(.*?)".*?<p class="star">(.*?)</p>.*?<p class="releasetime">(.*?)'
                       '</p>.*?<i class="integer">(.*?)</i><i class="fraction">(.*?)</i>',re.S)
    
        #获取页面
        def get_html(self,url):
            req = request.Request(url=url, headers=self.headers)
            rep = request.urlopen(req)
            html = rep.read().decode("utf-8")
            return html
    
        #入口函数
        def run(self):
            page=(int)(input("请输入页码数:"))
            #计算页面
            offset=(page-1)*10
            #拼接url
            url=self.url.format(offset)
            html=self.get_html(url)
            lists=self.pattern.findall(html)
            for i in lists:
                print("电影名:" + i[0].strip())
                print(i[1].strip())
                print(i[2].strip())
                print("评分:" + i[3] + i[4])
    
    
    if __name__ == "__main__":
        maoyan=Maoyan_spider()
        maoyan.run()

     最终效果如下:

    展开全文
  • 正则表达式之贪婪匹配与非贪婪匹配

    万次阅读 多人点赞 2018-10-07 16:14:06
    在前面正则表达式匹配规则里,提到了 .* . :匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符,请使用像 '[.\n]' 的模式 * :匹配0个或多个 使用 .* 的话就可以匹配任意长度的任意字符,但是有...
  • 贪婪匹配与非贪婪匹配。 就好比一个男人,一个渣男心里想的,老子就要全天下所有的女人。 而像我这种老实人,只想对喜欢自己的人好。 所以,这里的我就是非贪婪。而渣男就是贪婪的。即贪婪:想要的更多,...
  • 正则表达式的贪婪和非贪婪匹配

    千次阅读 2019-06-14 13:03:40
    贪婪匹配:正则表达式一般趋向于最大长度匹配。 非贪婪匹配:匹配到结果就好。 默认是贪婪模式。在量词后面直接加一个问号?就是非贪婪模式。 量词:{m.n}:m到n个 *:任意多个(表示匹配0-无穷) +:一个到多个...
  • 主要介绍了python正则表达式的懒惰匹配和贪婪匹配说明,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 区别如下所示: import re text = "<a> 你好 </a> <a> hello </a>" re_pat = "<a>.* </a>" re.findall(re_pat, text) ['<a> 你好 </a> <....
  • 但因为其属于贪婪匹配,所以有的时候并不能得到想要的结果。例如: import re string='hell 123123 world' res=re.match('he.*(\d+).*rld$',string) print(res.group(1)) 其目的是为了获取其中的数字,但输出的...
  • python 贪婪匹配与非贪婪匹配

    千次阅读 2019-05-14 08:39:00
    贪婪匹配
  • Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;非贪婪则相反,总是尝试尽可能稍的字符。 在“*”“?”“+”“{m,n}”后面机上?,是贪婪变成非贪婪。 ...
  • 主要介绍了Java正则之贪婪匹配、惰性匹配的相关资料,需要的朋友可以参考下
  • 贪婪匹配和非贪婪匹配的区别 .* 和 .*?举例如下:  从字符串"888|666|544"中提取最后一个竖线|后面的内容,但是在这个字符串中,竖线的个数不是固定的 。 使用hive中的regexp_extract...
  • 1.什么是正则表达式的贪婪与非贪婪匹配  如:String str="... 贪婪匹配:正则表达式一般趋向于最大长度匹配,也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str,结果就是匹配到:abcaxc(ab*c)。 ...
  • 贪婪匹配

    2016-10-06 17:23:37
    最后需要特别指出的是,正则匹配默认是贪婪匹配,也就是匹配尽可能多的字符。举例如下,匹配出数字后面的0:>>> re.match(r'^(\d+)(0*)$', '102300').groups() ('102300', '')\d+ 贪地尽可能多的匹配,所以后面的0*...
  • vim中如何贪婪匹配

    2020-11-17 08:58:12
    vim中如何贪婪匹配 vim中的匹配实在是不如perl好用,一直想实现非贪婪匹配,今天偶然发现可以用量词匹配来实现,具体可以看:h /{ {n,m} Matches n to m of the preceding atom, as many as possible {n} Matches n ...
  • ', s): 综上所述,在以下几种情况下非贪婪匹配可以发挥出它的作用: *?: 匹配0到任意多个字符; +?: 匹配一个到任意多个字符; {m, n}?: 最少匹配m个,最多匹配n个字符; ??: 匹配0~1个; 总结: python的正则表达式...
  • python3 贪婪匹配和非贪婪匹配 正则

    千次阅读 2019-01-20 09:53:59
    在python中默认采用的是贪婪模式,使用非贪婪模式的话,只需要在量词后面直接加上一个问号”?”。  在第一篇文章中介绍了正则表达式当中的量词一共有五种:  ...
  • 什么是贪婪匹配呢? 废话不多说 先看一段代码案例把 如下: $string='aaaaaaabbbbbbbbbbbbccccccc'; //如下 $pattern='/ab+/'; //或者说是如下 $pattern='/ab.+/'; preg_match($pattern, $string,$arr); show($arr); ...
  • // *、+ 为贪婪模式,最大限度的匹配 public class Test001 { public static void main(String[] args) throws Exception { String text = "John writes about this, and John Doe writes about that, and ...
  • * 与? * 通配符,匹配0个或多个字符 ...(.*):贪婪匹配,即尽可能多地匹配字符 如下: 检索结果十分贪婪,把1、2和3的“s”都吃掉了。 (.*?):懒惰匹配,即匹配尽可能少的字符,但是要匹配出所有的结果 ...
  • 正则表达式之—— 贪婪匹配与懒惰匹配 先举个栗子: res=“aabab” 贪婪:a.*+b 结果:aabab 懒惰:a.*+b 结果:aab,ab 那么对于有数字的字符串又有什么区别呢,这里依旧给出一个栗子。 import re res = “aabab ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,756
精华内容 19,502
关键字:

贪婪匹配