精华内容
下载资源
问答
  • re模块
    千次阅读
    2021-04-27 21:48:31

    1:正则表达式

    • 正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑
    • 可是说使用一组字符串来对另一组字符串来进行杀筛选和过滤的作用
    • 可以把正则表的式比作一个筛子

    2:正则表达式的用途

    • 爬虫
    • 表达验证

    3:✨re模块的常用方法

    3.1普通字符

    • 字母、数字、汉字、下划线、以及没有特殊定义的符号,都是"普通字符"。正则
      表达式中的普通字符,在匹配的时候,只匹配与自身相同的一个字符。
    • 普通字符可以理解为找一个和这个字符一摸一样的字符,没用别的功能了

    3.2:match()函数

    • 有三个参数:pattent, string, flags
      • pattent:正则表达式的模板,就像上面说的式筛子的筛字啊孔的大小
      • string:要匹配的数据,相当于要晒得谷物
      • flags:标志位,匹配的方式,比如是否区分大小写,是否匹配换行,re默认不换行,相当于要晒选谷物是要好看的还是难看的
    • 返回值
      • 如果数据和表达式匹配成功了,则返回一个match对象,否则返回None

    例子

    import re
    
    patten = 'python'
    str1 = 'pytho and java'
    
    res = re.match(patten, str).group()
    if res:
    	print(res)
    else:
    	print('没有匹配到!')
    
    注意:
    • match()函数的返回类型是一个match对象,要想显示这个对象里面的内容可以使用group()方法
    • group():返回match对象的内容
    • groups():以元组的形式返回match对象的内容

    3.3:元字符

    • re模块使用了很多的元字符,用来表示一些特殊的含义或功能
      • 小数点(“.”):可以匹配除了换行(\n)之外的任意一个字符
      • 逻辑或(“|”):可以匹配任意两个字符如:a|b 既可以匹配a,也可以匹配b
        • 注意:match()函数的特点,是以最前面的字符开始匹配,若匹配成功则返回,匹配不成功则抛出异常。但是search()函数不是从第一个字符开始匹配的,所以match()函数和search()函数可以灵活使用
      • 方括号(”[]“):可以匹配字符集中的一个字符如:[abc]2既可以匹配a2、b2也可以匹配c2
      • 取反操作(”[^]“):对字符集取反操作,也就是上面子集的反操作。尖号必须放在方括号的最前面
      • ”-“:至操作1-5相当于:12345
      • 注意:在re中的元字符不是正表达式该有的逻辑,正则表达式的模板中出现了一些元字符,但是这些元字符不在正则表达式的逻辑中,要使用转义字符”\“来处理一下,因为在re中的元字符也可以使用这些字符如".=.”这个地方的”.“只是代表一个点,不具有匹配任意不换行字符的功能了

      3.4:预定义匹配字符集

      • 可以直接拿来用的字符集模板
      • 正则表达式中的一些表示方法,可以同时匹配某个预定义字符集中的任意一个字符。比如,表达式\d可以匹配任意一个数字。虽然可以匹配其中任意字符,但是只能是一个,不是多个
      预定义字符集总结
      预定义字符集描述
      \d可以匹配0-9中的任意一个数字,等效于[0123456789]、[0-9]
      \w可以匹配任意一个字母、数字或下划线,等效于[a-zA-Z0-9_]
      \s可以匹配空格,制表符或其他的空白
      \D\d的反集,也就是除了数字不能匹配之外,别的字符都可以匹配
      \W\d的反集,也就是除了字母、数字和下划线不能匹配之外,别的字符都可以匹配
      \S\s的反集,也就是除了空格、制表符和其它的空白不能匹配之外,其余的字符都可以匹配

    3.5:重复匹配

    • 前面的表达式,无论是只能匹配一种字符的表达式,还是可以匹配多种字符其中任意一个的表达式,都只能匹配一次。但是有时候我们需要对某个字段进行重复匹配,例如手机号码13666666666,一般的新手可能会写成\d\d\d\d\d\d\d\d\d\d\d(注意,这不是一个恰当的表达式),不但写着费劲,看着也累,还不⼀定准确恰当。
      这种情况可以使用表达式再加上修饰匹配次数的特殊符号{},可以不用重复书写表达式就可以重复匹配。例如
      [abcd][abcd]可以写成[abcd]{2}
      
      重复匹配符号总结
      符号描述
      {n}表示重复n次。如:\b{3} = \b\b\b,a{3} = aaa
      {m,n}表示至少重复m次,最多重复n次,m:下限,n:上限。比如:ab{1,3}可以匹配ab,abb还可以匹配abbb
      {m,}表示至少重复m次。比如:a{2,}可以匹配aaa、aaaa还可以匹配aaaaaaaa
      {,n}表示至少可以匹配n次
      *可以匹配表达式0次到任意次,是用来表示数量的。和{0,}是等效的比如:^*b可以匹配b、^b还可以匹配^^^b
      +可以匹配表达式1次到任意次,也是用来表示数量的,和”*“唯一的差别就是不能匹配到0次

    3.6:位置匹配和非贪婪匹配

    • 贪婪匹配

      • 以尽可能匹配的最长的结果返回,python默认的就是贪婪匹配
    • 非贪婪匹配

      • 就是尽可能匹配最短的结果返回,在贪婪匹配的后面加一个?

    开始和结尾

    • ^:开始匹配的地方
    • $:匹配结束的地方

    4:爬虫的使用

    前面的内容 + .*? + 后面的内容

    5:re模块的常用方法

    常见方法总结
    方法名描述返回值
    compile(pattern, flags)根据包含正则表达式的字符串,创建模式对象re类型的pattern对象
    search(pattern,strings,flags)在字符串中查找第一个匹配的对象或None
    match(pattern,strings,flags)在字符串的开始处,开始匹配的模式在字符串开头匹配到的对象或None
    split(pattern,string,maxsplit=0,flags)根据模式的匹配来分割字符串分割后的字符串列表
    filldall(pattern,string,flags)列出字符串中所有的匹配项所有匹配到的字符串列表
    sub(pattern,repl,strings,count=0,flags)将字符串中的所有pattern项,用repl项替代完成替换后的新字符串

    5.1:compile()方法

    • 是re模块的工厂方法,返回的是一个re的patten对象
    • 用法:
    import re
    pat = re.compile(r'abc123', re.S)		# re.S标志位:意味着可以换行匹配
    respones = pat.match('abc123').gloup()
    print(response)
    -----------------输出-------------------
    'abc123456'
    

    5.2:search()方法

    • 在字符串中查找匹配的模板,也就是不是从第一个位置的字符串开始查找的,且只匹配一个字符串
    • 用法:
    import re
    pat = re,search(r'abc123','defabc123')
    print(pat.gloup())
    ----------输出----------------
    abc123
    

    5.3:match方法

    • 和search()方法的作用是一样,唯一不不同的就是match方法是从第一个字符开始匹配的,如果第一个字符不符合要求就返回None,但是search方法是从整个字符串开始匹配的,如果整个字符串没有则返回None,且只匹配一个符合要求的字符串
    • 用法
    import re
    pat = re.compile(r'abc123456', re.I)        # re.I:表示忽略大小写
    b = pat.search('defabc123456')
    print(b.group())
    -------------------输出-----------------------
    None
    

    5.4:findall方法

    • 与match方法和search方法的不同之处就是,前两个方法都是单值匹配,而findall方法是全文匹配,返回的形式为一个列表。因为返回形式是一个列表,所以不用使用gloup方法来显示pattern对象的内容。注意如果返回值是一个空列表,可能是正则表达式的模板错了
    • 用法
    import re
    pat = re.compile(r'abc123abc')
    a = pat.findall('123abc123')
    print(a)
    --------输出---------
    ['abc123','abc123']
    

    5.5:spilt方法

    • 参数:
      • 1:pattern:分割字符串的标志,就是以什么作为分割的标准
      • 2:maxsplit:最大的分割次数,默认为最多次,也就是分割完全
    • 用法
    import re
    s = '1+2*3/4-5'
    a = re.split(r'[\+\-\*\/]',s)
    print(a)
    ----------输出----------------------
    ['1','2', '3', '4']
    
    • 注意:split方法的返回值也是一个咧列表

    5.6:sub方法

    • 使用一个新的字符来代替另一个旧的字符,和字符串的replace方法的用法相似
    • 用法
    import re
    a = '1211111111456789'
    c = re.sub('1', '2', a)
    print(c)
    -------------输出------------
    2222222222456789
    
    • 总结
      • sub方法的默认替换是替换全部的字符

    6:分组功能

    • 把已经匹配到的内容,再次筛选出,我需要的内容,相当于二次分组,说白了,我不仅要筛选内容还要获得内容
    • 实现分组的方法:使用小括号()来进行分组
    • 获得分组的内容:使用gloup()方法来获得
    • 注意:
      • gloup():获得整个分组,也就是这个字符串的本身
      • gloup(1):获取取第一个分组
      • gloup(n):获取第n个分组,注意分组的开始是由1开始的
      • gloup(0):获取整个分组
      • gloups():获取所有的分组,且把返回值返回保存在一个元组中
    • 实例
    import re
    s = 'apple price is $66,banana price is $55'
    # 需求是匹配 $66 $55
    pat = r'.+(\$\d+).+(\$\d+)'
    a = re.search(pat, s)
    print(a.group())
    print(a.group(0))
    print(a.group(1))
    print(a.group(2))
    print(a.groups())
    ---------------输出-------------------
    apple price is $66,banana price is $55
    apple price is $66,banana price is $55
    $66
    $55
    ('$66', '$55')
    

    7:flag匹配模式

    7.1:re.S

    • 使‘.’这个通配符,能够匹配换行在内的所有字符,针对多行匹配

    7.2:re.I

    • 使匹配对大小写不敏感,也就是忽略大小写的匹配
    更多相关内容
  • 本文实例讲述了Python使用re模块正则提取字符串中括号内的内容操作。分享给大家供大家参考,具体如下: 直接上代码吧: # -*- coding:utf-8 -*- #! python2 import re string = 'abe(ac)ad)' p1 = re.compile(r'[(]...
  • 本文的实例将通过re模块来在python实现正则表达式,文末会逐渐增加一些re模块的讲解,平时要写作业,可能更新较慢。 想要了解re模块的更多信息可以在Python中运行help(re) 2.数据集的展示 首先我们先展示一下数据...
  • re模块-正则 .txt

    2019-09-26 13:55:59
    <html> <head> <title>re模块,学习笔记</title> </head> <body> <h2>python 学习笔记 <body/> </html>
  • 本文实例讲述了python的re模块应用。是非常重要的应用技巧。分享给大家供大家参考。 具体方法如下: import re # match_object = re.match('foo','foo') if match_object is not None: print type(match_object) ...
  • 解析并提取想要的数据:re  4.保存提取后的数据:with open()文件处理  爬蟲三步曲:  1.发送请求  2.解析数据  3.保存数据 注意:豆瓣网页爬虫必须使用请求头,否则服务器不予返回数据 import re import ...
  • 以上所述是小编给大家介绍的python re模块的高级用法详解,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对软件开发网网站的支持! 您可能感兴趣的文章:python下os...
  • 正则表达式(Regluar Expressions)又称规则表达式,在代码中常简写为REs,regexes或regexp(regex patterns)。这篇文章主要介绍了正则表达式+Python re模块详解,需要的朋友可以参考下
  • 主要介绍了Python使用re模块实现信息筛选的方法,结合实例形式分析了Python正则re模块进行信息筛选操作的相关实现技巧及相关函数使用技巧,需要的朋友可以参考下
  • 主要介绍了python正则表达式re模块详细介绍,本文翻译自官方文档,并加入了自己的理解,需要的朋友可以参考下
  • 主要介绍了使用的re模块的正则匹配的表达式,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • Python3的re模块(正则表达式)的具体使用文档。。。。。
  • Python re模块用法详解

    千次阅读 2022-03-10 12:25:46
    Python re模块用法详解 在 Python 爬虫过程中,实现网页元素解析的方法有很多,正则解析只是其中之一,常见的还有 BeautifulSoup 和 lxml,它们都支持网页 HTML 元素的解析操作。本节重点讲解如何使用 re 正则解析...

    Python re模块用法详解

    在 Python 爬虫过程中,实现网页元素解析的方法有很多,正则解析只是其中之一,常见的还有 BeautifulSoup 和 lxml,它们都支持网页 HTML 元素的解析操作。本节重点讲解如何使用 re 正则解析模块实现网页信息的提取。

    注意:在学习本节知识之前,您应该基本掌握了 Python re 模块的常用方法。

    re模块常用方法

    1) re.compile()

    该方法用来生成正则表达式对象,其语法格式如下:

    regex=re.compile(pattern,flags=0)
    

    参数说明:
    pattern:正则表达式对象。
    flags:代表功能标志位,扩展正则表达式的匹配。

    2) re.findall()

    根据正则表达式匹配目标字符串内容。

    re.findall(pattern,string,flags=0)
    

    该函数的返回值是匹配到的内容列表,如果正则表达式有子组,则只能获取到子组对应的内容。参数说明如下:
    pattern:正则表达式对象。
    string:目标字符串
    flags:代表功能标志位,扩展正则表达式的匹配。

    3) regex.findall()
    该函数根据正则表达式对象匹配目标字符串内容。其语法格式如下:

    regex.findall(string,pos,endpos)
    

    参数说明:
    string 目标字符串。
    pos 截取目标字符串的开始匹配位置。
    endpos 截取目标字符串的结束匹配位置。

    4) re.split()

    该函数使用正则表达式匹配内容,切割目标字符串。返回值是切割后的内容列表。参数说明:

    re.split(pattern,string,flags = 0)
    

    参数说明:
    pattern:正则表达式。
    string:目标字符串。
    flags:功能标志位,扩展正则表达式的匹配。

    5) re.sub

    该函数使用一个字符串替换正则表达式匹配到的内容。返回值是替换后的字符串。其语法格式如下:

    re.sub(pattern,replace,string,max,flags = 0)
    

    其参数说明:
    pattern:正则表达式。
    replace:替换的字符串。
    string:目标字符串。
    max:最多替换几处,默认替换全部,
    flags:功能标志位,扩展正则表达式的匹配。

    5) re.search()

    匹配目标字符串第一个符合的内容,返回值为匹配的对象。语法格式如下:

    re.search(pattern,string,flags=0)
    

    参数说明:
    pattern:正则表达式
    string:目标字符串

    flags功能标志位

    功能标志位的作用是扩展正则表达的匹配功能。常用的 flag 如下所示:

    flag功能标志位

    缩写元字符说明
    A元字符只能匹配 ASCII码。
    I匹配忽略字母大小写。
    S使得.元字符可以匹配换行符。
    M使 ^ $ 可以匹配每一行的开头和结尾位置。

    注意:可以同时使用福多个功能标志位,比如 flags=re.I|re.S。

    下面使用贪婪和非贪婪两种模式来匹配 HTML 元素,分别,如下所示:

    import re
    html="""
    <div><p>www.ccc.net</p></div>
    <div><p>C语言</p></div>
    """
    #贪婪匹配,re.S可以匹配换行符
    #创建正则表达式对象
    pattern=re.compile('<div><p>.*</p></div>',re.S)
    #匹配HTMLX元素,提取信息
    re_list=pattern.findall(html)
    print(re_list)
    #非贪婪模式匹配,re.S可以匹配换行符
    pattern=re.compile('<div><p>.*?</p></div>',re.S)
    re_list=pattern.findall(html)
    print(re_list)
    

    输出结果:

    ['<div><p>www.ccc.net</p></div>\n<div><p>C语言</p></div>']
    ['<div><p>www.ccc.net</p></div>', '<div><p>C语言</p></div>']
    

    从上述输出结果可以得出非贪婪模式比适合提取 HTML 信息。

    正则表达式分组

    通过正则表达式分组可以从匹配的信息中提取出想要的信息。示例演示:

    #正则表达式分组
    website="编程帮 www.ccc.net"
    #提取所有信息
    #注意此时正则表达式的 "." 需要转义因此使用 \.
    pattern_1=re.compile('\w+\s+\w+\.\w+\.\w+')
    print(pattern_1.findall(website))
    #提取匹配信息的第一项
    pattern_2=re.compile('(\w+)\s+\w+\.\w+\.\w+')
    print(pattern_2.findall(website))
    #有两个及以上的()则以元组形式显示
    pattern_3=re.compile('(\w+)\s+(\w+\.\w+\.\w+)')
    print(pattern_3.findall(website))
    

    输出结果:

    ['C语言 www.ccc.net']
    ['C语言']
    [('C语言', 'www.ccc.net')]
    

    正则表达式分组是提取信息的常用方式。当需要哪个特定信息的时候,就可以通过分组(也就是加括号)的方式获得。

    网页信息提取

    实战演练:从下面的 HTML 代码中使用 re 模块提取出两部影片的名称和主演信息。

    html="""
    <div class="movie-item-info">
    <p class="name">
    <a title="你好,李焕英">你好,李焕英</a>
    </p>
    <p class="star">
    主演:贾玲,张小斐,沈腾
    </p>    
    </div>
    <div class="movie-item-info">
    <p class="name">
    <a title="刺杀,小说家">刺杀,小说家</a>
    </p>
    <p class="star">
    主演:雷佳音,杨幂,董子健,于和伟
    </p>    
    </div> 
    """
    # 寻找HTML规律,书写正则表达式,使用正则表达式分组提取信息
    pattern=re.compile(r'<div.*?<a title="(.*?)".*?star">(.*?)</p.*?div>',re.S)
    r_list=pattern.findall(html)
    print(r_list)
    # 整理数据格式并输出
    if  r_list:
        for r_info in  r_list:
            print("影片名称:",r_info[0])
            print("影片主演:",r_info[1].strip())
            print(20*"*")
    

    输出结果如下:

    [('你好,李焕英', '\n主演:贾玲,张小斐,沈腾\n'), ('刺杀,小说家', '\n主演:雷佳音,杨幂,董子健,于和伟\n')]
    
    影片名称: 你好,李焕英
    影片主演: 主演:贾玲,张小斐,沈腾
    ********************
    影片名称: 刺杀,小说家
    影片主演: 主演:雷佳音,杨幂,董子健,于和伟
    ********************
    
    展开全文
  • re模块详解

    千次阅读 2021-02-03 00:16:28
    4.Python Re模块 Python 自带了re模块,它提供了对正则表达式的支持。主要用到的方法列举如下 1 2 3 4 5 6 7 8 9 10 #返回pattern对象 re.compile(string[,flag]) #以下为匹配所用函数 re.match(pattern,string[,...

    1.了解正则表达式

    正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。

    正则表达式是用来匹配字符串非常强大的工具,在其他编程语言中同样有正则表达式的概念,Python同样不例外,利用了正则表达式,我们想要从返回的页面内容提取出我们想要的内容就易如反掌了。

    正则表达式的大致匹配过程是:

    1.依次拿出表达式和文本中的字符比较,

    2.如果每一个字符都能匹配,则匹配成功;一旦有匹配不成功的字符则匹配失败。

    3.如果表达式中有量词或边界,这个过程会稍微有一些不同。

    2.正则表达式的语法规则

    下面是Python中正则表达式的一些匹配规则,图片资料来自CSDN

    297ccb313ea5d43781c158556891e188.png

    3.正则表达式相关注解

    (1)数量词的贪婪模式与非贪婪模式

    正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;非贪婪的则相反,总是尝试匹配尽可能少的字符。例如:正则表达式”ab*”如果用于查找”abbbc”,将找到”abbb”。而如果使用非贪婪的数量词”ab*?”,将找到”a”。

    注:我们一般使用非贪婪模式来提取。

    (2)反斜杠问题

    与大多数编程语言相同,正则表达式里使用”\”作为转义字符,这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”,那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\\\”:前两个和后两个分别用于在编程语言里转义成反斜杠,转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

    Python里的原生字符串很好地解决了这个问题,这个例子中的正则表达式可以使用r”\\”表示。同样,匹配一个数字的”\\d”可以写成r”\d”。有了原生字符串,妈妈也不用担心是不是漏写了反斜杠,写出来的表达式也更直观勒。

    4.Python Re模块

    Python 自带了re模块,它提供了对正则表达式的支持。主要用到的方法列举如下

    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[,maxsplit])

    re.findall(pattern,string[,flags])

    re.finditer(pattern,string[,flags])

    re.sub(pattern,repl,string[,count])

    re.subn(pattern,repl,string[,count])

    在介绍这几个方法之前,我们先来介绍一下pattern的概念,pattern可以理解为一个匹配模式,那么我们怎么获得这个匹配模式呢?很简单,我们需要利用re.compile方法就可以。例如

    1

    pattern=re.compile(r'hello')

    在参数中我们传入了原生字符串对象,通过compile方法编译生成一个pattern对象,然后我们利用这个对象来进行进一步的匹配。

    另外大家可能注意到了另一个参数 flags,在这里解释一下这个参数的含义:

    参数flag是匹配模式,取值可以使用按位或运算符’|’表示同时生效,比如re.I | re.M。

    可选值有:

    1

    2

    3

    4

    5

    6

    •re.I(全拼:IGNORECASE):忽略大小写(括号内是完整写法,下同)

    •re.M(全拼:MULTILINE):多行模式,改变'^'和'$'的行为(参见上图)

    •re.S(全拼:DOTALL):点任意匹配模式,改变'.'的行为

    •re.L(全拼:LOCALE):使预定字符类\w\W\b\B\s\S取决于当前区域设定

    •re.U(全拼:UNICODE):使预定字符类\w\W\b\B\s\S\d\D取决于unicode定义的字符属性

    •re.X(全拼:VERBOSE):详细模式。这个模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。

    在刚才所说的另外几个方法例如 re.match 里我们就需要用到这个pattern了,下面我们一一介绍。

    注:以下七个方法中的flags同样是代表匹配模式的意思,如果在pattern生成时已经指明了flags,那么在下面的方法中就不需要传入这个参数了。

    (1)re.match(pattern, string[, flags])

    这个方法将会从string(我们要匹配的字符串)的开头开始,尝试匹配pattern,一直向后匹配,如果遇到无法匹配的字符,立即返回None,如果匹配未结束已经到达string的末尾,也会返回None。两个结果均表示匹配失败,否则匹配pattern成功,同时匹配终止,不再对string向后匹配。下面我们通过一个例子理解一下

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    __author__='CQC'

    # -*- coding: utf-8 -*-

    #导入re模块

    import re

    # 将正则表达式编译成Pattern对象,注意hello前面的r的意思是“原生字符串”

    pattern=re.compile(r'hello')

    # 使用re.match匹配文本,获得匹配结果,无法匹配时将返回None

    result1=re.match(pattern,'hello')

    result2=re.match(pattern,'helloo CQC!')

    result3=re.match(pattern,'helo CQC!')

    result4=re.match(pattern,'hello CQC!')

    #如果1匹配成功

    ifresult1:

    # 使用Match获得分组信息

    print result1.group()

    else:

    print'1匹配失败!'

    #如果2匹配成功

    ifresult2:

    # 使用Match获得分组信息

    print result2.group()

    else:

    print'2匹配失败!'

    #如果3匹配成功

    ifresult3:

    # 使用Match获得分组信息

    print result3.group()

    else:

    print'3匹配失败!'

    #如果4匹配成功

    ifresult4:

    # 使用Match获得分组信息

    print result4.group()

    else:

    print'4匹配失败!'

    运行结果

    1

    2

    3

    4

    hello

    hello

    3匹配失败!

    hello

    匹配分析

    1.第一个匹配,pattern正则表达式为’hello’,我们匹配的目标字符串string也为hello,从头至尾完全匹配,匹配成功。

    2.第二个匹配,string为helloo CQC,从string头开始匹配pattern完全可以匹配,pattern匹配结束,同时匹配终止,后面的o CQC不再匹配,返回匹配成功的信息。

    3.第三个匹配,string为helo CQC,从string头开始匹配pattern,发现到 ‘o’ 时无法完成匹配,匹配终止,返回None

    4.第四个匹配,同第二个匹配原理,即使遇到了空格符也不会受影响。

    我们还看到最后打印出了result.group(),这个是什么意思呢?下面我们说一下关于match对象的的属性和方法

    Match对象是一次匹配的结果,包含了很多关于此次匹配的信息,可以使用Match提供的可读属性或方法来获取这些信息。

    属性:

    1.string: 匹配时使用的文本。

    2.re: 匹配时使用的Pattern对象。

    3.pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。

    4.endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。

    5.lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组,将为None。

    6.lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组,将为None。

    方法:

    1.group([group1, …]):

    获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名;编号0代表整个匹配的子串;不填写参数时,返回group(0);没有截获字符串的组返回None;截获了多次的组返回最后一次截获的子串。

    2.groups([default]):

    以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代,默认为None。

    3.groupdict([default]):

    返回以有别名的组的别名为键、以该组截获的子串为值的字典,没有别名的组不包含在内。default含义同上。

    4.start([group]):

    返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引)。group默认值为0。

    5.end([group]):

    返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1)。group默认值为0。

    6.span([group]):

    返回(start(group), end(group))。

    7.expand(template):

    将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组,但不能使用编号0。\id与\g是等价的;但\10将被认为是第10个分组,如果你想表达\1之后是字符’0’,只能使用\g0。

    下面我们用一个例子来体会一下

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    # -*- coding: utf-8 -*-

    #一个简单的match实例

    import re

    # 匹配如下内容:单词+空格+单词+任意字符

    m=re.match(r'(\w+) (\w+)(?P.*)','hello world!')

    print"m.string:",m.string

    print"m.re:",m.re

    print"m.pos:",m.pos

    print"m.endpos:",m.endpos

    print"m.lastindex:",m.lastindex

    print"m.lastgroup:",m.lastgroup

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

    print"m.group(1,2):",m.group(1,2)

    print"m.groups():",m.groups()

    print"m.groupdict():",m.groupdict()

    print"m.start(2):",m.start(2)

    print"m.end(2):",m.end(2)

    print"m.span(2):",m.span(2)

    printr"m.expand(r'\g \g\g'):",m.expand(r'\2 \1\3')

    ### output ###

    # m.string: hello world!

    # m.re:

    # m.pos: 0

    # m.endpos: 12

    # m.lastindex: 3

    # m.lastgroup: sign

    # m.group(1,2): ('hello', 'world')

    # m.groups(): ('hello', 'world', '!')

    # m.groupdict(): {'sign': '!'}

    # m.start(2): 6

    # m.end(2): 11

    # m.span(2): (6, 11)

    # m.expand(r'\2 \1\3'): world hello!

    (2)re.search(pattern, string[, flags])

    search方法与match方法极其类似,区别在于match()函数只检测re是不是在string的开始位置匹配,search()会扫描整个string查找匹配,match()只有在0位置匹配成功的话才有返回,如果不是开始位置匹配成功的话,match()就返回None。同样,search方法的返回对象同样match()返回对象的方法和属性。我们用一个例子感受一下

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    #导入re模块

    import re

    # 将正则表达式编译成Pattern对象

    pattern=re.compile(r'world')

    # 使用search()查找匹配的子串,不存在能匹配的子串时将返回None

    # 这个例子中使用match()无法成功匹配

    match=re.search(pattern,'hello world!')

    ifmatch:

    # 使用Match获得分组信息

    print match.group()

    ### 输出 ###

    # world

    (3)re.split(pattern, string[, maxsplit])

    按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数,不指定将全部分割。我们通过下面的例子感受一下。

    1

    2

    3

    4

    5

    6

    7

    import re

    pattern=re.compile(r'\d+')

    print re.split(pattern,'one1two2three3four4')

    ### 输出 ###

    # ['one', 'two', 'three', 'four', '']

    (4)re.findall(pattern, string[, flags])

    搜索string,以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下

    1

    2

    3

    4

    5

    6

    7

    import re

    pattern=re.compile(r'\d+')

    print re.findall(pattern,'one1two2three3four4')

    ### 输出 ###

    # ['1', '2', '3', '4']

    (5)re.finditer(pattern, string[, flags])

    搜索string,返回一个顺序访问每一个匹配结果(Match对象)的迭代器。我们通过下面的例子来感受一下

    1

    2

    3

    4

    5

    6

    7

    8

    import re

    pattern=re.compile(r'\d+')

    forminre.finditer(pattern,'one1two2three3four4'):

    printm.group(),

    ### 输出 ###

    # 1 2 3 4

    (6)re.sub(pattern, repl, string[, count])

    使用repl替换string中每一个匹配的子串后返回替换后的字符串。

    当repl是一个字符串时,可以使用\id或\g、\g引用分组,但不能使用编号0。

    当repl是一个方法时,这个方法应当只接受一个参数(Match对象),并返回一个字符串用于替换(返回的字符串中不能再引用分组)。

    count用于指定最多替换次数,不指定时全部替换。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    import re

    pattern=re.compile(r'(\w+) (\w+)')

    s='i say, hello world!'

    print re.sub(pattern,r'\2 \1',s)

    def func(m):

    returnm.group(1).title()+' '+m.group(2).title()

    print re.sub(pattern,func,s)

    ### output ###

    # say i, world hello!

    # I Say, Hello World!

    (7)re.subn(pattern, repl, string[, count])

    返回 (sub(repl, string[, count]), 替换次数)。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    import re

    pattern=re.compile(r'(\w+) (\w+)')

    s='i say, hello world!'

    print re.subn(pattern,r'\2 \1',s)

    def func(m):

    returnm.group(1).title()+' '+m.group(2).title()

    print re.subn(pattern,func,s)

    ### output ###

    # ('say i, world hello!', 2)

    # ('I Say, Hello World!', 2)

    5.Python Re模块的另一种使用方式

    在上面我们介绍了7个工具方法,例如match,search等等,不过调用方式都是 re.match,re.search的方式,其实还有另外一种调用方式,可以通过pattern.match,pattern.search调用,这样调用便不用将pattern作为第一个参数传入了,大家想怎样调用皆可。

    函数API列表

    1

    2

    3

    4

    5

    6

    7

    match(string[,pos[,endpos]])|re.match(pattern,string[,flags])

    search(string[,pos[,endpos]])|re.search(pattern,string[,flags])

    split(string[,maxsplit])|re.split(pattern,string[,maxsplit])

    findall(string[,pos[,endpos]])|re.findall(pattern,string[,flags])

    finditer(string[,pos[,endpos]])|re.finditer(pattern,string[,flags])

    sub(repl,string[,count])|re.sub(pattern,repl,string[,count])

    subn(repl,string[,count])|re.sub(pattern,repl,string[,count])

    具体的调用方法不必详说了,原理都类似,只是参数的变化不

    展开全文
  • python的re模块总结.pdf

    2020-02-29 22:54:55
    用" \\\\ "表示正则表达式中的" \ ",因为正则表达式中如果要匹配" \ ",需要用 变成" \\ ",而Python语法中又需要对字符串中每一个进行转义,所以就变成了" \\\\ "。 Python特别设计了原始字符串(raw string) ...
  • 文章目录一、正则表达式1、概念2、常用正则表(元字符)3、代码示例二、re模块1、re模块的使用1.1、findall(pattern,string,flags = 0 )用法1.2、re.match(pattern,string,flags = 0 )用法1.3、re.search...
  • python标准模块--re模块

    2021-08-04 20:35:54
    python中的re模块极大的方便了正则表达式的编写,下面来看re模块中的主要操作函数, 正则表达式并不是python的原生语法,python中使用正则表达式必须依靠re模块,下面介绍一些re模块中的常用函数 函数 描述 ...

    正则简介

    可能用到的网站

    1. oschina开源中国

    正则表达式是一种由特殊符号组成的序列,可以用于检查某一个字符串是否与某种结构匹配# 基础知识

    正则表达函数

    正则表达式并不是python的原生语法,python中使用正则表达式必须依靠re模块,下面介绍一些re模块中的常用函数

    函数描述返回结果
    compile(pattern[,flags])将正则表达式转化为一个正则表达式对象,flags用于指定正则匹配模式,如re.S)pattern对象
    findall(pattern,str[,flags])匹配所有符合条件的文本列表形式
    finditer(pattern,str[,flags])匹配所有符合条件的文本迭代对象(Match对象)
    match(pattern,str[,flags])从头开始匹配一个Match类对象
    search(pattern,str[,flags])从任意位置开始匹配一个Match类对象
    sub(pattern,repl,string[,count,flags])正则匹配替换,count表示替换次数(默认全部替换,并不改变原字符串)原字符串的拷贝并替换
    subn(pattrn,repl,string[count,flags])正则匹配替换,并返回替换结果
    split(pattern,str[,maxsplit,flags])按给定匹配符号拆分字符串

    正则表达式的使用示例见下文:re模块使用的两种形式,下面介绍match()和search()函数

    match函数

    match函数会从一个字符串开头开始匹配,匹配成功则返回一个Match类的对象,
    在这里插入图片描述

    search函数

    search函数可以c从一个字符串中的任意位置开始匹配,同时也会返回匹配结果的索引值

    在这里插入图片描述

    正则匹配符号

    元字符

    字符描述正则表达式举例
    ^匹配一行字符串的开始位置 或取反^http:表示匹配所有以‘http’开头的字符串
    $匹配一行字符串的结束位置
    |选择符号,表示或python\|pycharm:表示可以匹配python或pycharm
    .匹配除换行符外的任意一个字符
    {}大括号中加n表示重复次数(如{10}表示重复10次)(python){3}:表示一段包含三个“python”的字符串
    []一个字符集,表示匹配其中的某个;中括号中的“-”表示连续(如[0-9]表示0到9)[cij]python:表示可以匹配"cpython",“ipython”,“jpython”
    ()表示分组或括起来表示子表达式(a\|b)*c:表示匹配0个1个或多个a或b,后面紧跟字母c

    字符匹配符号

    正则是一组特殊符号的应用,下面介绍常用的正则符号

    符号描述
    x匹配任意一位字符
    \匹配转义字符
    \t制表符
    \n换行符
    \r匹配转义字符

    进行单个字符匹配,要匹配的字符串必须与单个字符的内容以及顺序保持一致,否则无法匹配
    除了单个字符,也可以设置要匹配字符的范围

    范围匹配符号

    范围匹配符号描述
    [abc]可能是abc任意一个
    [^abc]字母不是abc中任意一个
    a-zA-Z表示全部由字母组成,包括大小写
    0-9表示由数字组成

    案例一:字符匹配的范围控制

    在这里插入图片描述

    数量匹配符号

    符号描述待匹配符号举例正则表达式写法
    ?前面的匹配字符出现0或1次P、PYPY?
    *匹配字符出现0或1或多次P、PY、PYY、…PY*
    +匹配字符出现一次或多次PY、PYY、…PY+
    {n}匹配字符出现n次PYYYPY{3}
    {n,}匹配字符出现n次以上PY、PYY、PYYYPY{1,}
    {n,m}匹配字符出现n~m次PY、PYYPY{m,n}

    案例二:字符匹配的数量控制

    在这里插入图片描述

    简化正则表达式

    用于简化正则匹配符号定义,利用简化表达式可以对数字、字母、空格等内容进行匹配

    简化正则表达式匹配内容其它正则符号表示
    \d一位数字等价于[0-9]
    \D一位非数字等价于[^0-9]
    .任意一个字符,无法匹配换行符
    \w一位字母,数字或下划线,等价于[a-zA-Z0-9_]
    \W一位非字母,非数字或下划线等价于[^a-zA-Z0-9_]
    \s空白符(如换行符,tab)
    \S非空白符常与\s组合使用匹配所有的字符

    正则表达式中的逻辑符

    正则表达式中允许存在“与”“或”的逻辑关系

    正则逻辑表达式描述
    正则A正则B表达式A后紧跟表达式B
    正则A|正则B表达式A或表达式B

    案例三:多个示例正则表达式

    1. 匹配合法的ip地址:^\d{1,3}\.\d{1.3}\.\d{1.3}\.\d{1,3}
    2. 匹配是否为移动号码:^(13[1-9]\d{8})(15[01289]\d{8})$
    3. 匹配任意汉字(unicode编码):[\u4e00-\u9fa5]
    4. 匹配合法的身份证号码:^d{18}|\d{15}
    5. 匹配合法的电子邮箱地址:^\w+@(\w+\.)+\w+$

    正则匹配模式

    正则表达式匹配时通过正则匹配模式进行匹配控制
    下面介绍一些常用的正则匹配模式

    模式描述
    I忽略大小写
    L字符集本地化表示
    M多行匹配模式
    S使元字符’.'可以匹配换行符在内的任意字符
    X忽略正则表达式中的空白和注释
    U匹配unicode字符

    分组

    1. 一个正则表达式可以匹配任意多个数据内容,通过分组的形式对数据进行归类可以更加清晰地获得子数据
    2. 正则表达式中通过“()”定义分组。
    3. 如果没有使用分组,整个正则表达式默认为是一个隐含的全局分组(索引为0)

    分组正则表达式

    表达式模式描述
    (?P<name>...)分组命名模式可通过索引编号或name名称获取内容
    (?P=name)分组引用模式可以在正则表达式中引用前面命名过的正则表达式
    (?:...)分组不捕获模式计算索引时跳过该分组
    (...)默认分组捕获模式可单独取出分组内容

    正则分组函数

    根据索引返回正则匹配内容

    函数描述
    group()一个参数,返回单个字符串;多个参数,返回一个元组,元组里每一项对应一个参数。没有参数,参数默认为0(返回所有匹配内容)
    groups()返回一个包含所有匹配内容的元组
    groupdict()返回一个字典,包含所有经命名的匹配分组,键值是分组名

    注意:group()函数通过索引来获取数据,但是如果分组过多可能会造成索引混乱的问题,因此建议在进行分组时就对分组进行命名,后续通过分组名称获取数据

    案例四:利用分组匹配日期

    在这里插入图片描述

    实际运用

    re模块一般使用步骤

    1. 使用compile()函数将正则表达式的字符串形式生成为一个pattern对象
    2. 通过pattern对象的一系列方法对文本进行匹配,返回一个match对象
    3. 使用match对象的属性或方法查找所需要的信息

    re模块使用两种形式

    1. 使用格式:pattern对象.re模块常用函数(待匹配的文本)
      在这里插入图片描述
    2. 使用格式:re模块常用函数(pattern对象,待匹配的文本)
      在这里插入图片描述

    案例一:豆瓣250部分网页源码

    问题:从给定的一段代码中找到特定的信息

    <ol class="grid_view">
            <li>
                <div class="item">
                    <div class="pic">
                        <em class="">1</em>
                        <a href="https://movie.douban.com/subject/1292052/">
                            <img width="100" alt="肖申克的救赎" src="https://img2.doubanio.com/view/photo/s_ratio_poster/public/p480747492.webp" class="">
                        </a>
                    </div>
                    <div class="info">
                        <div class="hd">
                            <a href="https://movie.douban.com/subject/1292052/" class="">
                                <span class="title">肖申克的救赎</span>
                                        <span class="title">&nbsp;/&nbsp;The Shawshank Redemption</span>
                                    <span class="other">&nbsp;/&nbsp;月黑高飞(港)  /  刺激1995(台)</span>
                            </a>
    
    
                                <span class="playable">[可播放]</span>
                        </div>
                        <div class="bd">
                            <p class="">
                                导演: 弗兰克·德拉邦特 Frank Darabont&nbsp;&nbsp;&nbsp;主演: 蒂姆·罗宾斯 Tim Robbins /...<br>
                                1994&nbsp;/&nbsp;美国&nbsp;/&nbsp;犯罪 剧情
                            </p>                        
                            <div class="star">
                                    <span class="rating5-t"></span>
                                    <span class="rating_num"property="v:average">9.7</span>
                                    <span property="v:best" content="10.0"></span>
                                    <span>2424702人评价</span>
                            </div>
                                <p class="quote">
                                    <span class="inq">希望让人自由。</span>
                                </p>
                        </div>
                    </div>
                </div>
            </li>
    

    正则表达式实现

    # coding:utf-8
    import re
    text=open('肖申克的救赎.html','r')
    content=text.read()
    print(len(content))
    mode=re.compile(r'<div class="pic">.*?<span class="title">(?P<name>.*?)</span>',re.S)
    result=re.search(mode,content)
    print(result.group('name'))
    text.close()
    

    案例二:获取中国大学MOOC学校列表

    问题:如何从给定的一个网页原文件(网页见:网页源码)中找到所有的学校名称1

    在这里插入图片描述
    正则表达式实现

    import re
    import requests
    url='https://www.icourse163.org/university/view/all.htm#/'
    resp=requests.get(url)
    print(resp.status_code)
    mode='alt="(?P<name>.*?)">'
    list1=re.findall(mode,resp.text)
    for name in list1:
        print(name)
    

    1. 本案例参考《2021年9月计算机二级python考卷综合应用题》,有兴趣的小伙伴可以自己去找资源 ↩︎

    展开全文
  • 正则表达式也内嵌在Python中,通过re模块来实现,常用方法是findall(),会将匹配到的字符串用一个列表返回 例如: 要匹配一大串字符串中的所有数字,不用for循环和If语句,用re模块一行就能实现 import re print(re....
  • 复杂的正则表达式很难构建,甚至很难阅读。Ruby的Re模块可以帮助你利用简单的表达式构建复杂的正则表达式
  • Python 的 re 模块(Regular Expression 正则表达式)提供各种正则表达式的匹配操作,在文本解析、复杂字符串分析和信息提取时是一个非常有用的工具,下面我主要总结了re的常用方法
  • re模块下的函数 compile(pattern):创建模式对象 import re pat=re.compile('A') m=pat.search('CBA') #等价于 re.search('A','CBA') print m <_sre.SRE_Match object at 0x9d690c8> #匹配到了,返回Match...
  • python中的re模块

    万次阅读 多人点赞 2021-08-26 09:16:54
    python中的re模块 Python中re模块主要功能是通过正则表达式是用来匹配处理字符串的 第一步:import re 导入该模块后,就可以使用该模块下的所有方法和属性 import re re有很多的方法和属性 re 模块提供了不少有用...
  • re模块是python独有的匹配字符串的模块,该模块中提供的很多功能是基于正则表达式实现的,而正则表达式是对字符串进行模糊匹配,提取自己需要的字符串部分,他对所有的语言都通用。注意: re模块是python独有的 ...
  • Python之正则表达式(re模块

    千次阅读 2022-01-28 17:22:39
    re模块介绍 使用re模块的步骤 re模块简单应用示例 关于匹配对象的说明 说说正则表达式字符串前的r前缀 re模块综合应用实例 参考文档 提示:由于该站对MARKDOWN的表格支持的不是很好,所以本文中的表格均以...
  • 1.导入re模块:import re 2.初始化一个Regex对象:re.compile() 3.刚刚创建的Regex对象调用search方法进行匹配,返回要给March对象 4.刚刚的March对象调用group方法,展示匹配到的字符串 下面例子的知识点: 对正则...
  • python re模块

    2020-12-04 13:19:37
    python 里re模块有两种方式:# 将正则表达式编译成一个pattern规则对象pattern = re.compile("\d")pattern.match(): 从起始位置开始往后查找,返回第一个符合规则的,只匹配一次match(str,begin,end)(1)pattern = re...
  • 后续再分享re模块各个函数的详细功能。 元字符:可以简单认为一个有特殊含义的符号。 2 限制匹配的字符(集) 2.1 匹配单个字符 元字符:. 匹配规则:匹配除换行符外的任意一个字符。 print(re.findall('张.','张三...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 147,045
精华内容 58,818
关键字:

re模块

友情链接: radio.rar