Regex

正则表达式匹配手段
  通过设定有特殊意义的符号，描述符号和字符的重复行为及位置特征来表示一类特定规则的字符串

python ---> re模块  处理正则表达式

re.findall(pattern,string)
pattern:以字符串的形式传入一个正则表达式
string:要匹配的目标字符串
返回值：列表，将目标字符串中能用正则表达式匹配的内容放入列表

1.普通字符匹配（除了后续讲解的特殊字符全是普通字符）
  可以用普通字符来匹配对应的字符

2.或
元字符：|
匹配规则：匹配符号两侧的正则表达式均可
In [5]: re.findall('成都|走一走','和我在成都的街头走一走')
Out[5]: ['成都', '走一走']

3.匹配单个字符
元字符：.
匹配规则：匹配除 \n 外任意一个字符
In [7]: re.findall('成都|走.','和我在成都的街头走一走')
Out[7]: ['成都', '走一']

4.匹配开始位置
元字符：^
匹配规则：匹配目标字符串的开头位置（只有当目标字符串是开头时匹配）
In [15]: re.findall('^text','text lalala')
Out[15]: ['text']

5.匹配结束位置
元字符：$
匹配规则：匹配目标字符串的结束位置
In [17]: re.findall('py$','hello.py')
Out[17]: ['py']
In [18]: re.findall('py$','hello.pyc')
Out[18]: []

6.匹配重复
元字符：*
匹配规则：匹配前面出现的字符0次或多次 ->('o'字符出现0次或多次)
In [24]: re.findall('lo*','hello.py loo loooo')
Out[24]: ['l', 'lo', 'loo', 'loooo']

7.匹配重复
元字符：+
匹配规则：匹配前面出现的正则表达式1次或多次
In [25]: re.findall('lo+','hello.py loo loooo')
Out[25]: ['lo', 'loo', 'loooo']

8.匹配重复
元字符：?
匹配规则：匹配前面出现的正则表达式0次或1次
In [26]: re.findall('ab?','ababbasbsdabaababa')
Out[26]: ['ab', 'ab', 'a', 'ab', 'a', 'ab', 'ab', 'a']

9.匹配重复
元字符：{n}
匹配规则：匹配前面的正则表达式出现n次
In [28]: re.findall('ab{3}','ababbasbsdabbbbadfgaba')
Out[28]: ['abbb']

10.匹配重复
元字符：{m,n}
匹配规则：匹配前面的正则表达式m-n次
In [31]: re.findall('ab{2,4}','ababbasbsdabbbbadfgabbbba')
Out[31]: ['abb', 'abbbb', 'abbbb']

11.匹配字符集合
元字符：[字符集]
匹配规则：匹配字符集中任意一个字符，只能匹配一个
In [32]: re.findall('[aeiou]','hello world')
Out[32]: ['e', 'o', 'o']
In [36]: re.findall('^[A-Z][a-z]*','Hello world')
Out[36]: ['Hello']

12.匹配字符集
元字符：[^...]
匹配规则：匹配除了中括号中字符集以外的任意一个字符
In [38]: re.findall('[^!@#%]+','hello levi@123.com')
Out[38]: ['hello levi', '123.com']

13.匹配任意（非）数字
元字符：\d  \D
匹配规则：\d 匹配任意一个数字字符 [0-9]
          \D 匹配任意一个非数字字符 [^0-9]
In [43]: re.findall('1\d{10}','13988886666')
Out[43]: ['13988886666']
In [44]: re.findall('\D+','hello world')
Out[44]: ['hello world']

14.匹配任意(非)普通字符（数字字母下划线 普通utf-8字符）
元字符：\w  \W
匹配规则：\w 匹配任意一个普通字符
          \W 匹配任意一个非普通字符
In [45]: re.findall('\w+','hell$o')
Out[45]: ['hell', 'o']
In [46]: re.findall('\W+','hell$o')
Out[46]: ['$']

15.匹配（非）空字符 -> (空格 \r \n \t \v \f)
元字符：\s  \S
匹配规则：\s 匹配任意空字符
          \S 匹配任意非空字符
In [50]: re.findall('\w+\s+\w+','hello world')
Out[50]: ['hello world']
In [51]: re.findall('\S+','@$@#@ %@##@(')
Out[51]: ['@$@#@', '%@##@(']

16.匹配起止位置
元字符：\A  \Z
匹配规则：\A 匹配字符串开头位置 ^
          \Z 匹配字符串结尾位置 $

完全匹配：
  使用一个正则表达式可以匹配目标字符串的全部内容
In [53]: re.findall('\A\w{5}\d{3}\Z','abcde123')
Out[53]: ['abcde123']

17.匹配（非）单词边界
（普通位置和非普通字符的交界位置认为是单词边界）
元字符：\b  \B
匹配规则：\b 匹配单词边界位置
          \B 匹配非单词边界位置
In [56]: re.findall(r'\bis\b','this is a test')
Out[56]: ['is']

元字符总结：
匹配单个字符：
  a  .  [...]   [^...]  \d  \D  \w  \W  \s  \S
匹配重复：
  *  +  ?  {n}  {m-n}
匹配位置:
  ^  $  \A  \Z  \b  \B

正则表达式的转义

正则表达式特殊字符
  .  *  +  ?  $  []  {}  ()  \

在正则表达式中如果想要匹配这些特殊字符需要进行转义

raw 字符串 --->原始字符串
特点：
  对字符串中的内容不进行转义，即表达原始含义

r'\b' ---> \b
'\\b' ---> \b

e.g.
In [63]: re.findall('\w+@\w+\.cn','lvze@tedu.cn')
Out[63]: ['lvze@tedu.cn']

In [65]: re.findall('\\w+@\\w+\\.cn','lvze@tedu.cn')
Out[65]: ['lvze@tedu.cn']

In [66]: re.findall(r'\w+@\w+\.cn','lvze@tedu.cn')
Out[66]: ['lvze@tedu.cn']

python中要先对字符串进行解析，得出正则表达式，要注意和python中转义字符冲突

贪婪模式：
  正则表达式的重复，总是尽可能多的向后匹配内容。
*  +  ?  {m,n}

贪婪 ---> 非贪婪（懒惰）尽可能少的匹配内容
*?  +?  ??  {m,n}?
In [67]: re.findall(r'ab*?','abbbbbb')
Out[67]: ['a']

正则表达式分组
使用()可以为正则表达式建立子组，子组不会影响正则表达式整体的匹配内容。可以被看做是一个内部单元

子组作用：
1.形成内部整体，该变某些元字符的行为
In [69]: re.search(r'(ab)+','abababab').group()
Out[69]: 'abababab'
In [72]: re.search(r'\w+@\w+\.(cn|com)','lvze@tedu.com').group()
Out[72]: 'lvze@tedu.com'

2.子组匹配内容可以被单独获取
In [73]: re.search(r'\w+@\w+\.(cn|com)','lvze@tedu.com').group(1)
Out[73]: 'com'

子组的注意事项
* 一个正则表达式中可以有多个子组，区分第一子组，第二子组....
* 子组不要出现重叠的情况，尽量简单

捕获组和非捕获组（命名组，未命名组）
格式：(?P<name>pattern)
In [75]: re.search(r'(?P<dog>ab)+','abababab').groupdict()
Out[75]: {'dog': 'ab'}

作用：
1.方便通过名字区分每个子组
2.捕获组可以重复调用
  格式：(?P=name)

正则表达式的匹配原则
1.正确性  能够正确匹配目标字符串
2.唯一性  除了匹配的目标内容，尽可能不会有不需要的内容
3.全面性  对目标字符串可能的情况要考虑全面不遗漏

re 模块的使用

regex = re.compile(pattern,flags=0)
功能：生成正则表达式对象
参数：pattern 正则表达式
      flags 功能标志位，丰富正则表达式匹配 默认0不做标志位
返回值：一个正则表达式对象

re.findall(pattern,string,flags=0)
功能:根据正则表达式匹配目标字符串内容
参数：pattern  正则表达式
      string   目标字符串
返回值：列表  里面是匹配到的内容
        如果正则表达式有子组，则只返回子组中的内容
    多个子组时，返回多个匹配到的元组，元组里是子组所匹配到的内容

regex.findall(string,pos,endpos)
功能:根据正则表达式匹配目标字符串内容
参数：string  目标字符串
      pos,endpos : 截取目标字符串的起止位置进行匹配，默认是整个字符串
返回值：列表  里面是匹配到的内容
        如果正则表达式有子组，则只返回子组中的内容

re.split(pattern,string,flags=0)
功能：通过正则表达式切割目标字符串
参数：pattern  正则表达式
      string   目标字符串
返回值：以列表返回切割后的内容

re.sub(pattern,replace,string,max,flags)
功能：替换正则表达式匹配内容
参数：pattern  正则表达式
      replace  要替换内容
      string   目标字符串
      max      设定最多替换几处
返回值：替换后的字符串

re.subn(pattern,replace,string,max,flags)
功能：同sub
返回值：元组，(替换后的字符串,替换了几处)

re.finditer(pattern,string,flags)
功能：使用正则匹配目标字符串
参数：pattern 正则
      string  目标字符串
返回值：迭代对象 ---> 迭代内容为match对象

re.fullmatch(pattern,string,flags)
功能：完全匹配一个字符串
参数：pattern 正则
      string  目标字符串
返回值：match对象，匹配到的内容

re.match(pattern,string,flags)
功能：匹配一个字符串起始内容
参数：pattern 正则
      string  目标字符串
返回值：match对象，匹配到的内容

re.search(pattern,string,flags)
功能：匹配第一个符合条件的字符串
参数：pattern 正则
      string  目标字符串
返回值：match对象，匹配到的内容

regex 对象的属性

flags - 标志位数值
pattern - 正则表达式字符串
groups - 子组个数
groupindex - 获取捕获组字典，键为组名，值为第几组

作业：
1.读取一个文本
  匹配文本中所有以大写字母开头的单词
  匹配文本中所有数字  数字类型有 23 -12 1.23  40%  1/2
2.熟练元字符的使用规则
3.将finditer match search sub split 使用regex对象调用练习
4.复习tftp文件服务器项目

******************************************************

match 对象

pattern = r"(?P<dog>ab)cd(?P<cat>ef)"
regex = re.compile(pattern)
obj = regex.search("abcdefghijklmn")

属性：
obj.pos
目标字符串的起始位置
obj.endpos
目标字符串的终止位置
obj.re
正则表达式
obj.string
目标字符串
obj.lastgroup
最后一组的名称
obj.lastindex
最后一组是第几组

方法：
obj.span()
匹配内容的起止位置 -> 元组

obj.start()
匹配到内容的开始位置

obj.end()
匹配到内容的结束位置

obj.group(n=0)
功能：获取match对象对应的匹配内容
参数：默认为0  表示获取整体的匹配内容
      如果赋值1,2,3... 表示获取第n个子组匹配的内容
返回：返回获取到的内容字串

obj.groupdict()
获取所有捕获组（命名组）匹配到的内容形成字典

obj.groups()
获取所有子组匹配到的内容 -> 元组

flags 参数
作用：辅助正则表达式，扩展丰富匹配内容

I == IGNORECASE  忽略字母大小写
S == DOTALL  使元字符 . 能够匹配\n  
M == MULTILINE  使元字符 ^ $ 能匹配每一行的开头结尾
X == VERBOSE  能够为正则表达式添加注释

flags 传统多个标识符
re.I | re.M