zoukankan      html  css  js  c++  java
  • re模块与正则表达式

    正则表达式

    re 模块与正则表达式之间的关系

      正则表达式不是python独有的  它是一门独立的技术

      所有的编程语言都可以使用正则

      但是如果你想在python中使用,就要依赖re模块

        正则就是筛选字符串中的特定内容的

    正则应用场景

      1 爬虫

           2 数据分析

        注意:  一般情况下     re开头的都和正则有关系

    字符组     [字符组]
    在同一个位置可能会出现的噶种字符组,在正则表达式中用[]表示,当然可以也可以直接在这个位置上面写0,1,2,2,3,4,5,6,7,8,9这10个数字

                  元字符                    匹配内容
                  .                                        匹配除了换行符意外的任意字符
                  w                         匹配数字,字母,下划线
                  d                         匹配数字
                  s                         匹配任意的空白符
                 W                       匹配非数字,字母,下划线
                 D                         匹配非数字
                   S                             匹配非空白符
                                             匹配一个换行符
                                           匹配一个制表符
                                              匹配一个单词的结尾
                  ^                                    匹配字符串开头
                  $                          匹配字符串结尾
                 a|b                    匹配字符a或字符b(将长的放在前面)
                  ()                     匹配括号内的正则表达式          表示一个组
                 [...]                       匹配字符串中的字符
                     [^...]                                   匹配除了字符串中的所有字符

    ^与$符连用 会精准限制匹配的内容两者中间写什么 匹配的字符串就必须是什么多一个也不想少一个也不行

                  正则                 内容说明
                   [0-9]           表示0,1,2,3,4,5,6,7,8,9这个范围
                   [a-z]               表示小写的26个字母
                   [A-Z]               表示大写的26的字母
                [0-9a-zA-Z]          表示数字0-9小写26个字母大写的26字母
              量词                   用法说明
               *                   重复0次或多次
               +                   重复1次或多次
               ?                   重复0次或1次
              {n}                   重复n次
               {n,}                  重复n次或多次
              {n,m}                  重复n到m次
               <.*>            默认是贪婪匹配,尽可能的匹配长的字符串
               <.*?>        加上了?   从贪婪匹配转为非贪婪匹配,就是尽可能短的匹配字符串

    贪婪匹配:尽量的去多个值  在量词中,他们都是取贪婪匹配     默认情况下,采用贪婪匹配

    非贪婪匹配       加?     贪婪变非贪婪

    *?   重复的任意的次数,尽可能少重复

    +?  重复1次或多次   尽可能少重复

    ??  重复0次或1次  尽可能少重复

    {n,m}? 重复n到m次  尽可能少重复

    {n,}?  重复n次以上   尽可能少重复

    .*?的用法

    .  是任意字符

    *  是0到无线长度取值

    ?  是非贪婪匹配

    三个合在一起就是取尽量少的任意字符     

      应用场景      .

        *?x      表示的意思是前面取任意长度的字符,知道末尾有一个x出现

     

    re模块

    findall    返回所有满足要求的结果   放在一个列表中
    s = '0123456789'
    print(re.findall('1',s))  # ['1']
    print(re.findall('[0-3]',s))  # ['0', '1', '2', '3']
    print(re.findall('[0-9]',s))  # ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
    #
    print(re.findall('asd',s))  # []  查找的字符没有的话就返回空列表
    #
    s1 = 'hello my name is james'
    print(re.findall('[a-h]',s1))  # ['h', 'e', 'a', 'e', 'a', 'e']
    print(re.findall('[a]',s1))  # ['a', 'a']
    #
    print(re.findall('[123]',s1))  # []  没有返回空列表
    findall
    search 也是查找字符,但是search是再找到第一个符合要求的字符后就不找了   可以是多个连接的字符
    使用.group会找到
    s = 'egon owen mac'
    print(re.search('o',s))  # <_sre.SRE_Match object; span=(2, 3), match='o'>   返回一个这样的东西,说明search不能直接返回值使用.group
    print(re.search('k',s))  # None  不实用group方法没找到会返回None
    print(re.search('o',s).group())  # o
    print(re.search('ego',s).group())  # ego
    # print(re.search('k',s).group())  # 找不到 的会报错
    search
    match 和 search一样 也是查找元素在不在字符串中,使用group方法会返回值,但是不同的一点是他是检查是不是以什么开头的  如果不是直接报错
    s = 'egon owen mac'
    print(re.match('k',s))  # None  没有匹配到就返回None
    print(re.match('e',s).group())  # e 使用group方法匹配成功就返回输入的字符,没找到就报错
    # print(re.match('k',s).group())  # 没有匹配到  报错
    match
    split    切割不过是一次一次切     []里面的字符如果是都在字符串开头  那么就都打印出空字符串
    s = 'asadfaghjkl'
    print(re.split('a',s))  # ['', 's', 'df', 'ghjkl']  切一个字符    如果被切字符在开头第一个,
                              # 会输出一个空字符串,中间的不打印,但是也没有了,逗号隔开
    print(re.split('k',s))  # ['asadfaghj', 'l']   不是开头字符直接被切用逗号隔开
    print(re.split('[asa]',s))  # ['', '', '', 'df', 'ghjkl']    被切列表中有几个字符,就相当于是切了几次
                                  #先按照a切在用剩下的和s切在用剩下的和a再切  都已空字符串打印
    print(re.split('[fag]',s))  # ['', 's', 'd', '', '', 'hjkl']
    split
    sub  替换字符   但是这里有个参数可以控制修改几个
    ('被修改字符','修改后的字符',字符串名字,修改个数 )
    被修改可以写正则的 元字符
    s = '你好,你,你在吗'
    print(re.sub('.','x',s))  # xxxxxxxx
    print(re.sub('.','x',s,2))  # xx,你,你在
    print(re.sub('','',s))  # 我好,我,我在吗
    print(re.sub('','',s,1))  # 我好,你,你在吗
    sub
    subn 也是替换  不过是输出结果的元组,后面的参数是修改了的个数
    s = 'aaassaasdfaaghj'
    print(re.subn('w','3',s))  # ('333333333333333', 15)
    print(re.subn('a','3',s))  # ('333ss33sdf33ghj', 7)
    subn

    了解

    obj = re.compile('d{3}')  #将正则表达式编译成为一个 正则表达式对象,规则要匹配的是3个数字
    ret = obj.search('abc123eeee') #正则表达式对象调用search,参数为待匹配的字符串
    print(ret.group())  #结果 : 123
    #
    ret = re.finditer('d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
    print(ret)  # <callable_iterator object at 0x10195f940>
    print(next(ret).group())  #查看第一个结果
    print(next(ret).group())  #查看第二个结果
    print([i.group() for i in ret])  #查看剩余的左右结果
    View Code
  • 相关阅读:
    第四十三课:jQuery插件化
    js模块化开发
    第四十二课:基于CSS的动画引擎
    第四十一课:CSS3 animation详解
    第四十课:CSS3 transition详解
    第三十九课:requestAnimationFrame详解
    几种排序
    图与搜索
    数组
    链表
  • 原文地址:https://www.cnblogs.com/xuzhaolong/p/11203269.html
Copyright © 2011-2022 走看看