正则表达式

正则表达式：

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

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

 3、元字符的使用：
     
      （1）普通字符

                 元字符：a   b   c...

                 匹配规则：每个字符匹配对应的字符
       
      （2）或

                  元字符：  |

                  匹配规则：匹配  |  两边任意一个正则表达式

                  e.g.  In [8]: re.findall('ab|cd','abcdefghialajdcdad')
                        Out[8]: ['ab', 'cd', 'cd']
       
      （3）匹配单个字符

                    元字符：  .

                     匹配规则：匹配除换行外的任意字符

                     f.o  --->   foo   fao  f@o  ...

                    e.g.  In [10]: re.findall('f.o','foo is not fao')
                           Out[10]: ['foo', 'fao']
 
      （4）匹配开始位置

                      元字符：  ^

                      匹配规则：匹配目标字符串的开头位置

                       e.g.  In [16]: re.findall('^Tom','Tom is a boy')
                              Out[16]: ['Tom']

      （5）匹配结束位置

                     元字符：  $

                     匹配规则：匹配字符串的结束位置

                     e.g.   In [18]: re.findall("Tom$","hi Tom")
                             Out[18]: ['Tom']

      （6）匹配重复

                 元字符：  *

                匹配规则：匹配前面的字符出现0次或多次

               fo*  --->  foooo  f  fo

               e.g.  In [20]: re.findall("fo*","fadfafoooafo")
                      Out[20]: ['f', 'f', 'fooo', 'fo']

     （7）匹配重复

                      元字符：+

                     匹配规则：匹配前面的字符出现1次或多次

                      e.g   In [21]: re.findall("fo+","fadfooafo")
                            Out[21]: ['foo', 'fo']

                             In [22]: re.findall(".+\.py$","hello.py test.py")
                            Out[22]: ['hello.py test.py']

     （8）匹配重复

                 元字符： ？

                 匹配规则：匹配前面的字符出现0次或1次

                           fo?  --->  f   fo

                           e.g.  In [23]: re.findall("fo?","fadfofoooafo")

                                 Out[23]: ['f', 'fo', 'fo', 'fo']

     （9）匹配重复

                             元字符：{n}

                             匹配规则：匹配指定的重复次数

                              fo{3}  --->  fooo

                               e.g   In [24]: re.findall("fo{2}","fasdfoafoooo")
                               Out[24]: ['foo']

    （10）匹配重复

                        元字符：{m,n}

                       匹配规则：  匹配前面的正则表达式m--n次
                        f{2,4}  ---->   foo   fooo   foooo

                        e.g  In [25]: re.findall("fo{2,4}","fofoofooofosdd")
                             Out[25]: ['foo', 'fooo']

    （11）匹配字符集合

                          元字符：[字符集]

                          匹配规则：匹配任意一个字符集中的字符

                          [a-z]：任意一个小写

                          [A-Z]  ：任意一个大写

                          [0-9]：任意一个数字

                          [_123a-z]

                          e.g. In [28]: re.findall("^[A-Z][a-z]*",'Boy')
                                Out[28]: ['Boy']

    （12）匹配字符集

                             元字符：[^...]

                             匹配规则：表示字符集取非，除了列出的字符之外任意一个字符                       

                             [^abc]  --->  出a b c之外任意字符 


                              e.g.  In [30]: re.findall("[^ ]+","a little boy")
                              Out[30]: ['a', 'little', 'boy']
 
    （13）匹配任意（非）数字字符

                                  元字符：\d   \D

                                  匹配规则：\d匹配任意数字字符       [0-9]

                                                  \D匹配任意非数字字符   [^0-9]
                                   e.g.  In [33]: re.findall("\d",'1232')
                                         Out[33]: ['1', '2', '3', '2']

                                          In [34]: re.findall('1\d{10}','456115464654')
                                          Out[34]: []

                                          In [35]: re.findall("\D+","Num9")
                                          Out[35]: ['Num']
  
    （14）匹配任意（非）普通字符

                                 元字符：\w   \W

                                 匹配规则：\w   普通字符  [_0-9a-zA-Z]  也能匹配普通汉字    

                                           \W   非普通字符

                                        e.g   In [36]: re.findall("\w+","hello#nihao@sd!sa&")
                                               Out[36]: ['hello', 'nihao', 'sd', 'sa']

                                               In [37]: re.findall("\W+","hello#nihao@sd!sa&")
                                               Out[37]: ['#', '@', '!', '&']

    （15）匹配任意（非）空字符

                                      元字符：\s  匹配任意空字符  [ \r\t\n\v\f]

                                                   \S  匹配任意非空字符

                                              

                                      e.g.  In [38]: re.findall("\w+\s+\w+","hello  world")
                                            Out[38]: ['hello  world']

                                             In [40]: re.findall("\S+","hello this is tom")
                                             Out[40]: ['hello', 'this', 'is', 'tom']

    （16）、匹配字符位置


                        元字符：\A   \Z

                        匹配规则：\A 匹配字符串开头位置    ^

                                 \Z  匹配字符串结尾位置    $

                        

                      绝对匹配：正则表达式要完全匹配目标字符串内容

                                       在正则表达式开始和结束位置加上^  $(或者\A  \Z)。这样正则表达式必须匹配

                                       整个目标字符串才会有结果。

                              e.g. In [46]: re.findall("\A\d+\Z",'12334')
                                    Out[46]: ['12334']

     （17）匹配（非）单词边界

                        元字符：\b   \B

                        匹配规则：\b 匹配单词边界位置  普通字符和非普通字符交界认为是单词边界

                                   \B匹配非单词边界位置

                                 e.g.  In [49]: re.findall(r'num\b','num#asdf#')
                                       Out[49]: ['num']

---

元字符总结：

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

                    匹配重复：*   +   ？   {n}       {m,n}

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

                    其他：  |   ()    \

---