正则表达式_正则 @ (

正则表达式

产生的原因：

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

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

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

元字符的使用

1.元字符： |

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

In [21]: re.findall("ab|cd","abcdefghialkjasbab")
Out[21]: ['ab', 'cd', 'ab']
1
2

2.元字符： .

匹配规则：匹配除\n外的任意单字符

In [24]: re.findall("f.o","foo is not fao")
Out[24]: ['foo', 'fao']
1
2

3.元字符 ： ^

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

In [30]: re.findall("^Tom","Tom is a boy")
Out[30]: ['Tom']
1
2

4.元字符 ： $

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

In [32]: re.findall("Tom$","hi Tom")
Out[32]: ['Tom']
1
2

5.元字符 ： *

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

In [33]: re.findall("fo*","fadsfafoooafo")
Out[33]: ['f', 'f', 'fooo', 'fo']
1
2

6.元字符 ： +

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

In [36]: re.findall("fo+","fadsfafoooafo")
Out[36]: ['fooo', 'fo']
1
2

7.元字符 ： ？

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

In [42]: re.findall("fo?","fasdffoafooooo")
Out[42]: ['f', 'f', 'fo', 'fo']
1
2

8.元字符 ： {n}

匹配规则： 匹配前面的字符重复次数

In [43]: re.findall("fo{2}","fasdffoafooooo")
Out[43]: ['foo']
1
2

9.元字符 ： {m,n}

匹配规则 ： 匹配前面的字符出现 m–n次

In [46]: re.findall("fo{2,4}","fasdfofoooafooooo")
Out[46]: ['fooo', 'foooo']
1
2

10.元字符： [字符集]

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

In [51]: re.findall("^[A-Z][a-z]*","Boy")
Out[51]: ['Boy']
1
2

11.元字符 ： [^…]

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

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

In [54]: re.findall("[^ ]+","a little boy")
Out[54]: ['a', 'little', 'boy']
1
2

12.匹配任意（非）数字字符

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

In [57]: re.findall("1\d{10}","18888886666")
Out[57]: ['18888886666']
1
2

13. 匹配任意（非）普通字符

元字符 ： \w \W
匹配规则: \w 匹配任意普通字符 [_0-9a-zA-Z] 也能匹配普通汉字
\W 匹配任意非普通字符

re.findall("\w+","hello#nihao%asdf@adsgdfg!df&")
Out[60]: ['hello', 'nihao', 'asdf', 'adsgdfg', 'df']
    
re.findall("\W+","hello#nihao%asdf@adsgdfg!df&")
Out[63]: ['#', '%', '@', '!', '&']
1
2
3
4
5

14.匹配任意（非）空字符

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

In [65]: re.findall("\w+\s+\w+","hello   world")
Out[65]: ['hello   world']
    
In [66]: re.findall("\S+","hello this is tom")
Out[66]: ['hello', 'this', 'is', 'tom']
1
2
3
4
5

15.匹配字符串位置

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

在正则表达式开始和结束位置加上^ $ (或者\A \Z)。表示完全匹配

In [75]: re.findall("\A\d+\Z","123445")
Out[75]: ['123445']
1
2

16.匹配（非）单词边界

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

In [81]: re.findall(r"num\b","num#asdf#")
Out[81]: ['num']

In [82]: re.findall(r"num\b","numasdf#")
Out[82]: []
1
2
3
4
5

元字符总结

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

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

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

其他 ： |  ()  \

1
2
3
4
5
6
7
8
9

贪婪与非贪婪

贪婪模式：尽可能匹配多的

非贪婪模式：尽可能匹配少的

贪婪 ——> 非贪婪 *？ +？ ?? {m,n}?

正则表达式的子组

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

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

捕获组 和 非捕获组

格式 ： （?P<name>pattern）

re.search(r"(?P<dog>ab)cdef",'abcdefghti').group('dog')
Out[130]: 'ab'
1
2

正则表达式设计原则

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

re 模块

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

re.findall(pattern,string,flags=0)
功能 ：从目标字符串查找正则匹配内容
参数 ： 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=0)
功能： 替换正则匹配到的目标子串部分
参数： pattern
      replaceStr ： 要替换的内容
      string 
      max   最多替换几处 默认全部替换
      flags
返回值 ： 返回替换后的字符串

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


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

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

match(pattern,string,flags)
功能： 从开头位置匹配目标字符串
参数： pattern,string,flags
返回值：返回匹配到的match对象,如果没匹配成功返回None


search(pattern,string,flags)
功能： 正则表达式匹配目标字符串，只匹配第一处
参数： pattern,string,flags
返回值：返回匹配到的match对象,如果没匹配成功返回None

compile对象属性：

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

属性变量
pos     匹配目标字符串的开始位置
endpos  匹配目标字符串的结束位置
re      正则表达式
string  目标字符串
lastgroup  最后一组的组名
lastindex  最后一组是第几组

属性方法
start()  匹配内容的开始位置
end()    匹配内容的结束位置
span()   匹配内容的起止位置

group()
功能 ： 获取match对象对应的内容
参数 ： 默认为0 表示获取整个正则匹配的内容
        如果为序列号或者子组名则为获取某个子组匹配的对应内容
返回值：返回得到的子串

groupdict()  获取捕获组名作为键，对应内容作为值的字典
groups()   获取每个子组匹配内容


flags  参数的使用
re.compile  re.findall  re.search  re.match
re.finditer  re.fullmatch  re.sub  re.subn  re.split

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

I ==  IGNORECASE  匹配时忽略字母的大小写
S ==  DOTALL     作用于元字符 . 使其可以匹配换行 
M ==  MULTILINE  作用于^  $  使其可以匹配每一行开头结尾位置
X ==  VERBOSE    可以给正则添加注释

使用多个标志位使用按位或连接

e.g.
flags = re.X | re.I

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114