Python正则表达式的基本语法和使用

正则表达式
  动机：处理文本成为计算机常见工作之一
       对文本内容的搜索提取是一项比较复杂困难的工作
       为了快速方便处理上述问题，正则表达式技术诞生，逐渐发展为一个
       被众多语言使用的独立技术

  定义：即高级文本匹配模式，提供了搜索，替代等功能，本质是由一系列特
       殊符号和字符组成的子串，这个子串既是正则表达式。这个表达式描述了字符和字符的重复行为，可以匹配一类特征的字符串

  目标：熟练使用正则表达式符号
       正确组合和理解一般的正则表达式
       能够使用python操作正则表达式

  特点：方便进行检索和修改
       支持语言众多
       灵活多样
       mongo正则类型
       mongo正则类型，django等框架作为url匹配，爬虫

正则表达式的使用
  python -----> re模块　处理正则表达式
  re.findall(regex,string)
    功能：使用正则表达式匹配字符串
    参数：　pattern 正则表达式
          string 目标字符串
    返回值：　一个列表　匹配到的所有内容

    如：
    In [1]: s="my email is lvze@tedu.cn,rewei:wei@tedu.cn myemil
              is sehgn@kjl.cn"
    In [2]: import re
    In [4]: re.findall("\w+@\w+\.cn",s)
    Out[4]: ['lvze@tedu.cn', 'wei@tedu.cn', 'sehgn@kjl.cn']


  元字符(即正则表达式中有tesh含义的符号)
    普通字符
      元字符：abc
      匹配规则：匹配相应的普通字符
      In [5]: re.findall("abc","abckjflksdfabcdkjsdkf")
      Out[5]: ['abc', 'abc']
    或字符
      元字符：　ab|cd
      匹配规则：匹配|两边任意一个正则表达式符合的情况
      In [6]: re.findall("ab|cd","abckjflkscdfabcdkjcdkf")
      Out[6]: ['ab', 'cd', 'ab', 'cd', 'cd']
      In [8]: re.findall("ab|bc","abcdksabcdfabcd")
      Out[8]: ['ab', 'ab', 'ab']
      *|两侧不要有内用的空格
      * 如果有重复的字符串，只匹配第一个
    匹配单一字符
      元字符：　.
      匹配规则：匹配处理换行之外的任意字符
      f.o　---> foo fao f@o
      In [10]: re.findall("f.o","foo id not fao")
      Out[10]: ['foo', 'fao']
      In [12]: re.findall("你.","你好,你傻")
      Out[12]: ['你好','你傻']
    匹配开始位置
      元字符：　^
      匹配规则：匹配一个组字符串的开始位置
      ^Hello ----> Hello world : Hello
      In [13]: re.findall("^hello","hello world")
      Out[13]: ['hello']
      In [13]: re.findall("^hello","Tom,hello")
      Out[13]: []
    匹配结束位置
      元字符：　$
      匹配规则：匹配目标字符串的结束位置
      py$ ----> hello.py 
      In [15]: re.findall("py$","hello.py")
      Out[15]: ['py']
      In [17]: re.findall("py$","hello.pyc")
      Out[17]: []
    匹配重复
      元字符：　*
      匹配规则：匹配前面的正则表达式重复0次或多次
      In [19]: re.findall("ab*","abbcdaef")
      Out[19]: ['abb', 'a']
    匹配重复
      元字符：+
      匹配规则：匹配前面的正则表达式重复一次或多次
      In [20]: re.findall(".+","hello.py")
      Out[20]: ['hello.py']
    匹配重复
      元字符：?
      匹配规则：匹配前面的正则表式重复0次或1次
      In [22]: re.findall("ab?","abcdefa")
      Out[22]: ['ab', 'a']
    匹配重复
      元字符：　{n}
      匹配规则:匹配制定的重复次数
      ab{3} ---> abbb
      In [23]: re.findall("ab{3}","abbbbb")
      Out[23]: ['abbb']
    匹配重复
      元字符：{m,n}
      匹配规则：匹配指定正则表达式重复m　到n次
      ab{3,5} abbb abbbb abbbbb
      In [26]: re.findall("ab{2,5}","abcdabbbabbbbb")
      Out[26]: ['abbb', 'abbbbb']

    匹配字符集和
      元字符：[]
      匹配规则：匹配中括号范围内一个字符
      [abc123d] a b c d 1 2 3 d
      [a-z]
      [A-Z]
      [0-9]
      In [30]: re.findall("[a-z]","abcdabbbabbbbb")
      Out[30]: ['a', 'b', 'c', 'd', 'a', 'b', 'b', 'b', 'a', 'b', 'b', 'b', 'b', 'b']
      In [32]: re.findall("[_0-9a-zA-Z]","Hello world 123_")
      Out[32]: ['H', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '1', '2', '3', '_']
    匹配字符集合
    　　元字符： [^...]
      匹配规则：匹配除指定字符集之外的任意字符
      In [34]: re.findall("[^a-z]","Hello world 123_")
      Out[34]: ['H', ' ', ' ', '1', '2', '3', '_']
      In [35]: re.findall("[^_0-9a-zA-Z]","Hello world 123_")
      Out[35]: [' ', ' ']
    匹配任意数字(非)字符
      元字符：　\d \D
      匹配规则：　\d　匹配任意数字字符[0-9]　 \D　匹配任意非数字字符[^0-9]
      In [37]: re.findall("1\d{10}","17611665537")
      Out[37]: ['17611665537']
      In [41]: re.findall("\D+","hello 123")
      Out[41]: ['hello ']
    匹配(非)普通字符　(普通字符：数字字母下划线)
      元字符： \w      \W
      匹配规则：\w　匹配任意一个普通字符　\W匹配任意非普通字符
                  [_0-9a-zA-Z]        [^_0-9a-zA-Z]
      In [42]: re.findall("\w+","hello 123")
      Out[42]: ['hello', '123']
      In [44]: re.findall("\W+","hello$ 123")
      Out[44]: ['$ ']
    匹配(非)空字符
    　　元字符：\s  \S
      匹配规则：\s 匹配任意空字符　　\S 匹配任＋意非空字符
                  [ \n\t\r]
      In [45]: re.findall("\s","hello world")
      Out[45]: [' ']

      In [46]: re.findall("\S","hello world")
      Out[46]: ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'] 

      In [47]: re.findall("\s","hello world\r\n\t")
      Out[47]: [' ', '\r', '\n', '\t']
       \r 回车　　\t tab键　　\n  换行
      In [52]: re.findall("[A-Z]\S+","hello World nihao China###")
      Out[52]: ['World', 'China###']
    匹配起止位置
    　　元字符：　\A  \Z
      匹配规则：\A匹配开始位置　　\Z匹配结束位置
                  ^               $
      绝对匹配： \Aabc\Z --->abc(且字符串只是abc)
      In [57]: re.findall("\A/\w+/\w+\Z","/footbool/zhongchao")
      Out[57]: ['/footbool/zhongchao']
    匹配(非)单词边界位置
      元字符：　\b \B
      匹配规则：\b 匹配单词的边界　　\B　匹配非单词的边界
      单词边界：数字字母下划线和其他字符的交界位置为单词的边界
      In [59]: re.findall(r"\bis\b","This is a test")
      Out[59]: ['is']
      In [61]: re.findall(r"\Bis\b","This is a test")
      Out[61]: ['is']　
    匹配字符总结
      匹配单个字符：　a . \d \D  \w \W  \s \S [...] [^...]
      匹配重复性： * + ?  {n} {m,n}
      匹配某个位置：^ $ \A \Z \b \B
      其他(连接)　:　　　　　|或  　()分组  　\转义

练习：匹配长度8-10的密码　必须是以数字数字字母组成
　　^[0-9]\w{7,9}$


转义字符
  正则表达式特殊符号：.  *  ?  $  ''  ""  []  {}  ()  \  ^  
  如果想匹配特殊符号则加转义

  In [2]: re.findall("\"\.\"",'Thile is a "."')
  Out[2]: ['"."']

  In [3]: re.findall("\\\"\\.\\\"",'Thile is a "."')
  Out[3]: ['"."']
  In [4]: re.findall(r"\"\.\"",'Thile is a "."')
  Out[4]: ['"."']

                   代表
　　'''     \"\.\"------->"."     '''

　　
  r ----> raw 原生字符串：　不进行转义

贪婪和非贪婪
  正则表达式默认的重复匹配模式：贪婪模式
  尽可能多的向后匹配
  *  +  ?  {m,n}  这四种情况下会产生贪婪模式
　　
  非贪婪模式：尽可能少的匹配内容，满足正则表达式含义即可
  贪婪----> 非贪婪　*?  +?  ??  {m,n}?

  In [5]: re.findall("ab*?",'  abbbbbbdf')
  Out[5]: ['a']

  In [6]: re.findall("ab{2,5}?",'  abbbbbbdf')
  Out[6]: ['abb']

  In [7]: re.findall("ab??",'  abbbbbbdf')
  Out[7]: ['a']

  In [8]: re.findall("ab+?",'  abbbbbbdf')
  Out[8]: ['ab']

findall中如果有子组，只显示子组的内容，会把显示的内容放到元组里


正则表达式分组
  使用括号()　可以为一个正则表达式建立一个子组，子组可以看做内部的整体
  In [9]: re.findall("((ab)+)",'  abababababab')
  Out[9]: [('abababababab', 'ab')]
In [11]: obj=re.search("abcd(ef)",'abcdef')

In [12]: obj.grop()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-12-e89e705f2e72> in <module>()
----> 1 obj.grop()

AttributeError: '_sre.SRE_Match' object has no attribute 'grop'

In [13]: obj.group()
Out[13]: 'abcdef'

In [14]: obj.group(1)
Out[14]: 'ef'
  abcd(ef) ----->abcdef
  子组的作用：
    增加子组后对正则表达式整体的匹配内容没有影响
    子组可以改变重复元字符的重复行为
    子组在某些操作中可以对子组匹配内容单独提取

  子组的注意事项：
    每个正则表达式可以有多个子组，由外到内由左到右为第一第二...子组
    子组通常不要交叉

  捕获组和非捕获组(命名组和费命名组)
    子组命名格式：
      (?P<name>正则表达式)
    很多编程借口可以直接通过名字获取子组匹配内容
    捕获组中的正则表达式可以通过名字重复调用
      (?P=name)调用命名的子组
    (?P<dog>ab)cdef   调用：(?P=dog)

    In [16]: re.search("((ab)+)",'ababababab').group()
    Out[16]: 'ababababab'

    In [17]: re.search('(?P<dog>ab)
              cdef(?P=dog)',"abcdefabcde").group()
    Out[17]: 'abcdefab'
练习：匹配身份证号
In [21]: re.search("\d{17}(\d|x)",'12345645454545441x').group()
Out[21]: '12345645454545441x'


re模块
  obj=compile(pattern,flags=0)
   　功能：获取正则表达式对象

   　参数：pattern :正则表达式
         flags:功能标志位，提供更丰富的匹配
               默认是0,不添加任意标志位

    返回值：正则表达式对象

re模块和compile对象均有的函数：

  obj.findall(string,pos,endpos)
    功能：通过正则表达式匹配字符串

    参数： string 目标字符串
          pos  目标字符串的匹配开始位置
          endpos 目标字符串的结束位置

    返回值：匹配到的所有内容以列表返回
    * 如果正则表达式有子组则只显示子组匹配内容

 　obj.split(string)

    功能：按照正则表达式切割目标字符串

    参数：目标字符串

    返回值：切割后的内容
       
 　obj.sub(replaceStr,string,max)
    功能：替换正则表达式匹配到的内容

    参数：replaceStr 要替换的内容
          string 目标字符串
          max 最多替换几处

    返回值：返回替换后的字符串

 　subn(repl,string,count)
    功能：替换正则表达式匹配到的内容

    参数：replaceStr 要替换的内容
          string 目标字符串
          count 最多替换几处

    返回值：返回替换后的字符串和实际替换的个数 

 　obj.finditer(string)
    功能：使用正则表达式匹配内容
    参数：目标字符串
    返回值：迭代对象　迭代的每个内容为一个match对象

 　re.match(pattern,string)
    功能：匹配一个字符串的开头
    参数：目标字符串
    返回值：如果匹配到返回　match obj
           没有匹配到返回  None
 　re.search(pattern,string)
    功能：匹配一个字符串
    参数：目标字符串
    返回值：如果匹配到返回　match obj
           没有匹配到返回  None    
  * match 只能匹配字符串的开头位置，如果开头位置没有则报错
    search可以匹配任意位置，但是也只能匹配一处
  * 通常match对象调用其属性时往往需要try异常处理
    fullmatch()
    要求目标字符串完全匹配

  compile: 对象　　属性方法(re模块没有)
  flags:标志位
  pattern:正则表达式
  groupindex: 捕获组形成的字典
  groups:多少个子组


#group 获取实际匹配到的内容

match对象属性方法：
print(match_obj.pos)#目标字符串开头位置
print(match_obj.endpos)#目标字符串结束位置
print(match_obj.re)#正则表达式
print(match_obj.string)#目标字符串
print(match_obj.lastgroup)#最后一组的名字
print(match_obj.lastindex)#最后一组是第几组　

end()匹配到内容的结束位置
span()匹配到内容的起止位置
start()匹配到内容的开始位置
group()
  功能：获取match 对象匹配的内容
  参数：默认为0 表示获取正则整体的匹配内容
  　　　　　　如果传入大于0的正数则表示获取对应子组匹配内容
  返回值：返回匹配到的内容
groups()
  功能：得到所有子组匹配的内容
groupdict()
  功能：得到所有捕获组匹配的内容  (不能得到非捕获组内容)


作业：读取一个文件的内容，将文件中所有的一大写字母开头的单词匹配出来

　
flags 参数
  re.compile  re.findall  re.search  re.match  re.finditer re.fullmatch  re.sub  re.subn  re.split
  作用：辅助正则表达式，丰富匹配结果

A 
ASCII 

S      对元字符　. 起作用　让其可以匹配换行
DOTALL 对元字符　. 起作用　让其可以匹配换行
s='''hello world
Hello kitty
nihao China
'''
l=re.findall('.+',s,re.S)
print(l)

I          忽略大小写
IGNORECASE　忽略大小写
s="Hello World"
l=re.findall('h\w+',s,re.I)
print(l)

M          对元字符　^ $ 起作用，可以匹配每一行的开头结尾位置
MULTILINE
s='''hello world
Hello kitty
nihao China
'''
l=re.findall('China$',s,re.M)
print(l)

X       为正则添加注释
VERBOSE 为正则添加注释

多个flags 同时使用
　　re.I | re.X
s='''Hello world
Hello kitty
nihao China
'''
pattern ='''(?P<dog>hello)#dog组
\s+#空字符
(world)#第二组用来匹配'''
l=re.findall(pattern,s,re.X | re.I)
print(l)