正则表达式 (元字符的使用 正则表达式的转义 re模块)

正则表达式

动机:
1.文本处理已经成为计算机的常见工作之一
2.对文本内容的搜索,定位,提取是逻辑比较复杂的工作
3.为了快速解决上述问题,产生了正则表达式技术

定义:即文本的高级匹配模式,提供搜索,替代等功能,其本质是一系列由特殊        符号组成的字串,这个字串即正则表达式

匹配原理:由普通字符和特殊符号组成的字符串,通过描述字符的重复和位置等行为,达到匹配某一类字符串的目的

目标:
1.熟练掌握正则表达式符号
2.实现基本的文本搜索,定位,提取,理解正则用法
3.能够适用re模块操作正则表达式

特点:
*方便文本处理
*支持语音众多
*适用灵活多样

python--->re模块

re.findall(pattern,string)
功能:使用正则表达式匹配目标字符串内容
参数:pattern 正则表达式
    string  目标字符串
返回值: 列表  列表中为匹配到的内容

元字符的使用

1.普通字符

    元字符:a b c
    匹配规则:每个字符匹配对应的字符
    eg:
    >>> re.findall('\d+','hello 123 45678 4545')
    ['123', '45678', '4545']
2.或

    元字符:  |
    匹配规则:匹配|两边任意一个正则表达式
    eg:
    >>> re.findall('ab|cd','adjsjdbfjasbjdfbjasbjdbabhdbhafhbdaabcdabcd')
    ['ab', 'ab', 'cd', 'ab', 'cd']

3.匹配单个字符

    元字符:    .
    匹配规则:匹配除换行外的任意字符
    f.o--->foo fao f o
    eg:
    re.findall('f.o','fo is foo de fofofofao')
    ['foo', 'fao']
4.匹配开始位置

    元字符: ^
    匹配规则:匹配目标字符串的开头位置
    eg:
    >>> re.findall('Tom','Tom is a good boy')
    ['Tom']

5.匹配结束位置

    元字符:   $
    匹配规则:匹配字符串的结束位置
    eg:
    >>> re.findall('Tom$','he\ is a good boy Tom')
    ['Tom']

6.匹配重复
    
    元字符:  *
    匹配规则:匹配前面的字符出现0次或多次
    fo*--->fooooooooooo f fo
    eg:
    >>>re.findall('fo*','fadasfofoooofooooofooofooooooo')
    ['f', 'fo', 'foooo', 'fooooo', 'fooo', 'fooooooo']

7.匹配重复

    元字符: +
    匹配规则:匹配前面的字符出现一次或多次
    fo+----> fo  foooooo
    eg:
    >>>re.findall('fo+','fadasfofoooofooooofooofooooooooo')
    ['fo', 'foooo', 'fooooo', 'fooo', 'fooooooooo']

8.匹配重复

元字符: ?
匹配规则:匹配前面的字符出现0次或1次
fo?---->f fo
eg:
>>> re.findall('fo?','fasodofoffoooo')
['f', 'fo', 'f', 'fo']  

9.匹配重复

    元字符:{n}
    匹配规则:匹配指定的重复次数
    fo{3} ---> fooo
    eg:
    >>> re.findall('fo{2}','fasodofoffoooo')
    ['foo']
    >>> re.findall('fo{3}','fasodofoffoooo')
    ['fooo']
    >>> re.findall('fo{4}','fasodofoffoooo')
    ['foooo']

10.匹配重复
    
    元字符:{m,n}   
    匹配规则:匹配前面的正则表达式 m--n次
    fo{2,4}--->foo fooo foooo
    eg:
    >>> re.findall('fo{2,4}','fasodofooffoooo')
    ['foo', 'foooo']            

11.匹配字符集合

    元字符:[字符集]
    匹配规则:匹配任意一个字符集下的字符

    [abc123] a b c 1 2 3 12
    [a-z]
    [A-Z]
    [0-9]
    [_123a-z]
    eg:
    >>> re.findall('^[a-z][a-z]','boy')
    ['bo']
12.匹配字符集

    元字符:[^...]
    匹配规则:字符集取非,除了列出的字符之外任意一个字符

    [^abc]-->除abc之外任意字符
    eg:
    >>> re.findall('[^abcds]','boyadshfhjasjhbhjasf')
    ['o', 'y', 'h', 'f', 'h', 'j', 'j', 'h', 'h', 'j', 'f']

13.匹配任意(非)数字字符

    元字符: \d  \D
    匹配规则: \d 匹配任意数字字符      [0-9]
             \D 匹配任意非数字字符    []

             eg:
             >>> re.findall('\D','AID1807')
             ['A', 'I', 'D']

14.匹配任意(非)普通字符

    元字符:\w  \W
    匹配规则:\w 普通字符  
            \W 非普通字符
            eg:
            >>> re.findall('\w','我在北京')
            ['我', '在', '北', '京']
            
            >>> re.findall('\W','!@#$我在北京')
            ['!', '@', '#', '$']

15.匹配任意(非)空字符

    元字符:  \s 匹配任意空字符[ \r\t\n\v\f]
            \S 匹配任意非空字符
            eg:
            >>> re.findall('\w+\s+\w+','hello     beijin')
            ['hello     beijin']

            >>> re.findall('\w+\S+\w+','hello     beijin')
            ['hello', 'beijin']

16.匹配字符串位置

    元字符: \A \Z
    匹配规则:\A匹配字符串开头位置  ^
            \Z匹配字符串结尾位置  $
            >>> re.findall('\Ahello','hellobeijin')
            ['hello']
            >>> re.findall('beijin\Z','hellobeijin')
            ['beijin']

    绝对匹配:正则表达式完全匹配目标字符串内容
    在正则表达式的开头或者结尾加上^或者$(或者\A\Z).这样正则表达式必须匹配到整个目标字符串才会有结果

    eg:
    >>> re.findall('\A\d+$','1234568789')
    ['1234568789']

17.匹配(非)单词边界
    
    元字符: \b \B
    匹配规则:\b 匹配单词边界位置
            \B 匹配非单词边界位置
            普通字符和非普通字符认为是单词边界

            eg:
            >>> re.findall(r'he\b','he ##is a good gril')
            ['he']

 

元字符总结

    匹配单个字符: a  .  \d   \D  \s  \S  \w   \W
                [...]  [^...]

    匹配重复: *  +  ?  {n}  {m,n}

    匹配位置:^  $  \A  \Z  \b  \B

    其他:  |  ()  \

正则表达式转义

    正则中的特殊字符
        . * + ? ^ $ [] {} () | \

    正则表达式如果匹配特殊字符需要加\表达转义

    eg:             正则  目标字符串
    >>> re.findall('\$\d+','$10')
    ['$10']
             pattern     string
    python  '\\$\\d+'     '$10'

    python   r'\$\d+'     '$10'

    raw子串: 原始字符串对内容不解释转义,就表达内容原本的意义

贪婪和非贪婪

    贪婪模式:正则表达式的重复匹配总是尽可能多的向后匹配更多内容
        * + ? {m,n}
    非贪婪模式(懒惰模式):尽可能少的匹配内容

    贪婪--->非贪婪 *?  +?  ??   {m,n}?
    >>> re.findall(r'ab','abbbbbbbbbbb')
    ['ab']
    
    >>> re.findall(r'ab+','abbbbbbbbbbb')
    ['abbbbbbbbbbb']
    
    >>> re.findall(r'ab{3,5}?','abbbbbbbbbbb')
    ['abbb']

正则表达式的子组
    可以使用()为正则表达式建立子组,子组可以看做是正则表达式内部操作的一个整体

    *子组是在正则表达式整体匹配到内容的前提下才会发挥的作用,他不影响正则表达式整体去匹配目标内容这一原则

    子组作用
    1.作为内部整体可以改变某些原字符的行为
    eg:
    >>> re.search(r'(ab)+\d+','abababab123456').group()
    'abababab123456'
    2.子组在某些操作中可以单独提取出匹配内容
    >>> re.search(r'(https|http|ftp)://\S+','https://baidu.com').group()
    'https://baidu.com'

    子组使用注意事项:
        *一个正则表达式中可以有多个子组
        *子组一般由外到内,左到右称之为第一,第二,第三...子组
        *子组不能重叠,嵌套也不宜很复杂

        捕获组和非补货组

        格式:(?P<name>pattern)
        >>> re.search(r"(?P<dog>ab)cdef",'abcdefghijklmn').group('dog')
        'ab'

    作用:可以通过组名更方便获取某组内容

正则表达式设计原则:
    1.正确性:能正确匹配到目标内容
    2.排他性:除了要匹配的内容,尽可能不会匹配与到其他内容
    3.全面性:需要对目标的各种情况进行考虑,做到不遗漏

re模块

    compile
    regex = compile(pattern,flags = 0)
    功能:生成正则表达式对象
    参数:patter 正则表达式
        flags  功能标志位,丰富正则表达式的匹配功能

    返回值:返回正则表达式对象

    re.findall(pattern,string,flags)
    功能:从目标字符串查找正则匹配内容
    参数:pattern 正则表达式
             string  目标字符串
             flags   标志位
    返回值:返回匹配到的位置
           如果正确则有子组则只返回子组对应内容

    regex.findall(string,pos,endpos)
    功能:从目标字符串查找正则匹配内容
    参数:string  目标字符串
             pos     匹配目标的起始位置
             endpos  匹配目标的终止位置
    返回值:返回匹配到的位置
          如果正确则有子组则只返回子组对应内容

    re.split(pattern,string,flags=0)
    功能:根据正则匹配内容切割字符串
    参数: pattern  string  flags
    返回值:返回列表,列表中为切割的内容

    re.sub(pattern,replaceStr,string,max,flags)
    功能:替换正则匹配到的目标子串部分
    参数:pattern
             replaceStr:要替换的内容
             string
             max:最多替换几处,默认为全部替换
             flags:
    返回值:返回替换后的字符串
 
    re.subn(pattern,replaceStr,string,max,flags)
    功能:替换正则匹配到的目标子串部分
    参数:pattern
             replaceStr:要替换的内容
             string
             max:最多替换几处,默认为全部替换
             flags:
    返回值:返回一个元组为实际替换了几处和替换后的字符串

    re.finditer(pattern,string,flags)
    功能:使用正则表达式匹配目标字符串
    参数:pattern  string  flags
    返回值: 返回一个迭代对象,迭代到的内容是一个match对象

    fullmatch(pattern,string,flags)
    功能:完全匹配目标字串
    参数:pattern,string,flags
    返回值:返回匹配到的match对象
          如果没匹配成功返回NoneType

    match(pattern,string,flags)
    功能:从开头位置匹配目标字符串
    参数:pattern,string,flags
    返回值:返回匹配到的match对象
          如果没匹配成功返回NoneType
    
    search(pattern,string,flags)
    功能:正则表达式匹配目标字符串,只匹配第一处
    参数:pattern,string,flags
    返回值:返回匹配到的match对象
          如果没匹配成功返回NoneType

compile对象属性
    flags:标志位
    pattern:正则表达式
    groups:有多少子组
    groupindex:捕获组成组名和序列号的字典
               组名为键,第几组为值