正则表达式

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

定义：即文本的高级匹配模式，提供搜索，替代，查找等功能。本质是由一系列特殊符号和字符组成的字串。

目标：
1.熟练掌握正则表达式符号
2.能够看懂或者简单编写基本的正则表达式
3.能够使用python操作正则表达式

特点：
* 方便进行检索修改文本的操作
* 支持编程语言众多
* 使用灵活多样

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

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

s = "my email is Levi@126.com or lvze@tedu.cn"
re.findall("\w+@\w+\.\w{2,3}",s)

元字符 (正则表达式中有一定含义的符号)

1.普通字符
元字符 a b c & #
匹配规则：匹配字符本身

2.　或
元字符：|
匹配规则: 匹配 | 两边任意一个正则表达式

* | 左右不要有空格

3.匹配单一字符
元字符　.
匹配规则：匹配除\n外任意一个字符

4.匹配开始位置
元字符：　^
匹配规则：匹配一个字符串的开头位置

5.匹配结尾位置
元字符： $
匹配规则：匹配字符串的结束位置

6.匹配重复
元字符：　*
匹配规则：匹配前面的正则表达式重复0次或者多次

fo* ---> foo fooo fooooooooo

7.匹配重复
元字符：　+
匹配规则：匹配前面的正则表达式1次或多次

8.匹配重复
元字符：　?
匹配规则：匹配前面出现的元字符0次或1次

9.匹配重复
元字符: {n}
匹配规则：匹配前面的正则表达式n次
ab{3} --> abbb

10.匹配重复
元字符：{m,n}
匹配规则：匹配前面的正则表达式m--n次
ab{3,5} --> abbb abbbb abbbbb

11.匹配字符集合
元字符：[字符集]
匹配规则：匹配括号内的任意一个字符
[abc123] a b c 1 2 3
[a-z] [A-Z] [0-9]
[123a-zA-Z]

12.匹配字符集合
元字符：[^...]
匹配规则：除了字符集中的任意一个字符
[^abc] --> d e f....0

13.匹配任意(非)数字字符
元字符：\d  \D
匹配规则：\d 匹配任意数字字符
                  \D 匹配任意非数字字符
re.findall('1\d{10}','13233412323')
re.findall('\D+','13 The num 345')

14.匹配(非)普通字符 (数字字符下划线)
元字符： \w   \W
匹配规则：\w 匹配任意一个普通字符　[_0-9a-zA-Z]
                  \W 匹配任意一个非普通字符[^_0-9a-zA-Z]

15.匹配(非)空字符　(空格,\r \t \n \0)
元字符：\s 匹配任意空字符
匹配规则：\S 匹配任意非空字符

16.匹配起止位置
元字符：\A(^)  \Z($)
匹配规则：匹配字符串的开始和结束位置

绝对匹配：正则表达式前后加^$或\A\Z　表示正则表达式需要匹配目标字符串的全部内容

17.匹配(非)单词边界(普通字符和其他字符交界的位置为单词边界)
元字符：\b \B
匹配规则：\b 单词边界
                  \B 非单词边界

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

正则表达式转义

特殊符号：
. * ? [] () {} ^

r --- raw 字符串：　原生字符串，字符串的内容就是字符串本身，不进行任何转义处理

贪婪和非贪婪

贪婪模式：正则表达式的重复默认总是尽可能多的向后匹配内容

* + ? {m,n}

非贪婪模式：尽可能少的匹配内容
贪婪 ---> 非贪婪　 *? +? ?? {m,n}?

正则表达式分组

可以使用()为一个正则表达式建立子组，子组可以看做正则表达式的一个局部整体

子组的作用
1.子组作为一个局部整体可以改变某些元字符的行为，比如重复，或等

re.search('','').group()

2.子组在某些操作中可以单独提取匹配内容

re.search(r'(ab)+','ababababfagasfd').group(1)

子组使用注意事项
* 一个正则表达式中可以有多个子组，正则表达式依然是通过整体匹配内容
* 子组由外到内，由左到右为第一第二第三...子组
    ((ab)cd(ef)g)   abcdefg  ab  ef
*　子组内容不会重叠

捕获组和非捕获组(命名组，非命名组)

格式：(?P<name>pattern)

re.search(r'(?P<dog>ab)cdef','abcdef').group()

命名作用：
1.很多编程接口可以通过名称获取指定组的内容
2.命名组可以被重复调用
    格式：　(?P=name)

re.search(r'(?P<dog>ab)cd(?P=dog})','abcdab').group()

正则表达式设计原则
1.正确性，能够正确的匹配要求内容
2.唯一性，除了需要匹配的内容，尽可能不匹配不需要的内容
3.全面性，对目标特征考虑全面不遗漏

re模块

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

import re
s = 'abdeabc  dabht grabde  abcda bhtgr'
regex = re.compile(r'abcd')
l = regex.findall(s)
print(l)
# ['abcd']

list = re.findall(pattern,srting,flags)
功能：根据正则表达式匹配目标字符串
参数：pattern 正则表达式
    　   string 目标字符串
返回：返回一个列表，内部为匹配到的内容

* 如果正则表达式有分组则只显示子组内容

import re
s = 'abdeabc  dabht grabde  abcda bhtgr'
l1 = re.findall(r'((ab)d(ea))', s)
print(l1)
#[('abdea', 'ab', 'ea')]

list = regex.findall(string,pos=0,endpos=999)
功能：根据正则表达式匹配目标字符串
参数：string 目标字符串
    　   pos　标明从目标字符串的哪个位置开始匹配
       　endpos　标明匹配到目标字符串的哪里

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

import re
s = 'abdeabc  dabht grabde  abcda bhtgr'
l = re.split(r'\s+',s)
print(l)
#['abdeabc', 'dabht', 'grabde', 'abcda', 'bhtgr']

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

import re
s = 'abdeabc  dabht grabde  abcda bhtgr'
# 替换目标字符串
s1 = re.sub(r'\s+', '##', 'hello world  nihao    china', 2)
print(s1)
#hello##world##nihao    china 

re.subn(pattern,replaceStr,string,max,flags)
功能：替换正则表达式匹配到的内容
参数：pattern 正则
          replaceStr 要替换的内容
          string 目标字符串
          max 要替换几处
返回值：返回替换后的字符串和替换了几处

import re 
s = re.subn(r'\s+','##',"hello world  nihao  china")
print(s)
#('hello##world##nihao##china', 3)

re.finditer(pattern,string,flags)
功能：使用正则表达式匹配目标字符串
参数：pattern 正则
           string 目标字符串
返回值：将匹配内容生成迭代器

import re 
s = "2008年是个多事之秋,512地震,08奥运等"
it = re.finditer(r'\d+',s)
for i in it:
    print(i.group())
#2008
#512
#08

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

try:
    obj = re.fullmatch(r'\w+','abcde#f123')
    print(obj.group())
except AttributeError as e:
    print(e)
#'NoneType' object has no attribute 'group'

obj = re.match(pattern,string,flags)
功能：匹配目标字符串开头
参数：pattern 正则
           string 目标字符串
返回值：匹配到的内容　(match object)

obj = re.match('foo','foo,food on the table')
print(obj.group())
#foo

obj = re.search(pattern,string,flags)
功能：匹配目标字符串,只能匹配第一处
参数：pattern 正则
           string 目标字符串
返回值：匹配到的内容　(match object)

import re 
obj = re.search('foo','Foo,food on the table')
print(obj.group())
# foo

* 生成match对象如果失败会返回None,则无法调用match对象属性，此时会产生异常。

compile生成的正则对象属性

pattern 获取到正则对象对应的正则表达式
flags 获取标志位值
groupindex　获取捕获组形成的字典　组名为键，第几组为值
groups　多少子组

regex.groups

作业：
1.读取一个文本，将文本中所有以大写字母开头的单词匹配出来，将文本中数字匹配出来
2.熟练掌握元字符的匹配规则
3.将findall finditer match search sub split fullmatch 使用compile方法进行调用
4.看一下之前的项目　　

match object 属性函数

属性变量

pos
endpos
re
string
lastgroup
lastindex

import re
regex = re.compile(r'abcdef')
match_obj = regex.search("abcdefghijklmn",　0,　14)
print(match_obj.pos)  # pos 目标字符串开始位置
print(match_obj.endpos)   # endpos  目标字符串结束位置
# 0
# 14
print(match_obj.re)   # re 正则表达式
print(match_obj.string)    # string 目标字符串
# re.compile('abcdef')
# abcdefghijklmn

import re
regex = re.compile(r'(?P<dog>ab)cd(?P<pig>ef)')
match_obj = regex.search("abcdefghijklmn", 0, 14)
print(match_obj.lastgroup)  # lastgroup 最后一组名称
print(match_obj.lastindex)  # lastindex  最后一组是第几组
# pig
# 2

属性方法

end()
span()
start()

import re
regex = re.compile(r'(?P<dog>ab)cd(?P<pig>ef)')
match_obj = regex.search("abcdefghijklmn")
print(match_obj.start()) # 匹配到的起始位置
print(match_obj.end())  # 匹配到的结束位置
print(match_obj.span()) # 匹配到的起止位置
# 0
# 6
# (0, 6)

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

groups()
功能：将所有子组匹配内容形成一个元组

groupdict()
功能：将所有捕获组形成字典，组名为键，匹配内容为值

import re
regex = re.compile(r'(?P<dog>ab)cd(?P<pig>ef)')
match_obj = regex.search("abcdefghijklmn")
print(match_obj.group())  # 正则表达式匹配内容
print(match_obj.group(1))  # 子组第一组匹配到的内容
# abcdef
# ab
print(match_obj.groups())
print(match_obj.groupdict())
# ('ab', 'ef')
# {'dog': 'ab', 'pig': 'ef'}

flags　参数
compole  re.findall  re.search  re.match
re.finditer  re.fullmatch  re.sub  re.subn
re.split

作用：辅助正则表达式，丰富匹配结果

I == IGNORECASE 忽略大小写

import re
s = "Hello world"
pattern = r"hello"
l1 = re.findall(pattern, s, re.I)
print(l1)
# ['Hello']

S == DOTALL  元字符 . 匹配  \n

import re
s = '''
    hello world
    nihao Beijing
    '''
obj = re.search(r'.+', s, re.S)
print(obj.group())
#   hello world
#   nihao Beijing

M == MULTILINE  元字符^ $ 可以匹配每行的开头和结尾

import re
s = '''hello world
nihao Beijing
'''
regex = re.compile(r'world$', re.M)
l1 = regex.findall(s)
print(l1)
# ['world']

X == VERBOSE 可以给正则添加注释

# (?P<dog>H\w+\s+(world))
pattern = '''(?P<dog>H\w+) # dog组
\s+ # 任意多个空字符
(world) # 匹配world
'''
obj = re.match(pattern, 'Hello  world', re.X)
print(obj.group())
# Hello  world

多个标志位可以用 | 隔开

flags = re.X|re.I