Python_Crawler_Foundation1-2_MYSQL_Regular Expression

 Mysql

 

https://www.tutorialspoint.com/python/python_database_access.htm 

 

Regular Expression

 2. 正则表达式实例

^[A‐Za‐z]+$　　　　　　　 由26个字母组成的字符串
^[A‐Za‐z0‐9]+$　　  　   由26个字母和数字组成的字符串
^‐?\d+$　　　　　　　  　 整数形式的字符串
^[0‐9]*[1‐9][0‐9]*$　　　正整数形式的字符串
[1‐9]\d{5}　　　　　　 　中国境内邮政编码，6位
[\u4e00‐\u9fa5]　　　　 匹配中文字符
\d{3}‐\d{8}|\d{4}‐\d{7}　　国内电话号码，010‐68913536



IP地址字符串形式的正则表达式（IP地址分4段，每段0‐255）
\d+.\d+.\d+.\d+ 或\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}
精确写法：(([1‐9]?\d|1\d{2}|2[0‐4]\d|25[0‐5]).){3}([1‐9]?\d|1\d{2}|2[0‐4]\d|25[0‐5])

 

3.正则表达式相关注解

（1）数量词的贪婪模式与非贪婪模式

正则表达式一般用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也多是默认非贪婪），老是尝试匹配尽量多的字符；非贪婪的则相反，老是尝试匹配尽量少的字符。例如：正则表达式”ab*”若是用于查找”abbbc”，将找到”abbb”。而若是使用非贪婪的数量词”ab*?”，将找到”a”。

注：咱们通常使用非贪婪模式来提取。

（2）反斜杠问题

与大多数编程语言相同，正则表达式里使用”\”做为转义字符，这就可能形成反斜杠困扰。假如你须要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将须要4个反斜杠”\\\\”：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可使用r”\\”表示。一样，匹配一个数字的”\\d”能够写成r”\d”。有了原生字符串，妈妈也不用担忧是否是漏写了反斜杠，写出来的表达式也更直观勒。

4.Python Re模块

Python 自带了re模块，它提供了对正则表达式的支持。主要用到的方法列举以下

 1 #返回pattern对象
 2 re.compile(string[,flag])  
 3 #如下为匹配所用函数
 4 re.match(pattern,string[,flags])
 5 re.search(pattern,string[,flags])
 6 re.split(pattern,string[,maxsplit])
 7 re.findall(pattern,string[,flags])
 8 re.finditer(pattern,string[,flags])
 9 re.sub(pattern,repl,string[,count])
10 re.subn(pattern,repl,string[,count])

View Code

在介绍这几个方法以前，咱们先来介绍一下pattern的概念，pattern能够理解为一个匹配模式，那么咱们怎么得到这个匹配模式呢？很简单，咱们须要利用re.compile方法就能够。例如

 1 pattern=re.compile(r'hello')  

 

在参数中咱们传入了原生字符串对象，经过compile方法编译生成一个pattern对象，而后咱们利用这个对象来进行进一步的匹配。

另外你们可能注意到了另外一个参数 flags，在这里解释一下这个参数的含义：

参数flag是匹配模式，取值可使用按位或运算符’|’表示同时生效，好比re.I | re.M。

可选值有：   　　

1   •re.I(全拼：IGNORECASE):忽略大小写（括号内是完整写法，下同）
2   •re.M(全拼：MULTILINE):多行模式，改变'^'和'$'的行为（参见上图）
3   •re.S(全拼：DOTALL):点任意匹配模式，改变'.'的行为
4   •re.L(全拼：LOCALE):使预约字符类\w\W\b\B\s\S取决于当前区域设定
5   •re.U(全拼：UNICODE):使预约字符类\w\W\b\B\s\S\d\D取决于unicode定义的字符属性
6   •re.X(全拼：VERBOSE):详细模式。这个模式下正则表达式能够是多行，忽略空白字符，并能够加入注释。

 

在刚才所说的另外几个方法例如 re.match 里咱们就须要用到这个pattern了，下面咱们一一介绍。

注：如下七个方法中的flags一样是表明匹配模式的意思，若是在pattern生成时已经指明了flags，那么在下面的方法中就不须要传入这个参数了。

（1）re.match(pattern, string[, flags])

这个方法将会从string（咱们要匹配的字符串）的开头开始，尝试匹配pattern，一直向后匹配，若是遇到没法匹配的字符，当即返回None，若是匹配未结束已经到达string的末尾，也会返回None。两个结果均表示匹配失败，不然匹配pattern成功，同时匹配终止，再也不对string向后匹配。下面咱们经过一个例子理解一下

 1 __author__='CQC'
 2 # -*- coding: utf-8 -*-
 3  
 4 #导入re模块
 5 import re
 6  
 7 # 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”
 8 pattern=re.compile(r'hello')
 9  
10 # 使用re.match匹配文本，得到匹配结果，没法匹配时将返回None
11 result1=re.match(pattern,'hello')
12 result2=re.match(pattern,'helloo CQC!')
13 result3=re.match(pattern,'helo CQC!')
14 result4=re.match(pattern,'hello CQC!')
15  
16 #若是1匹配成功
17 ifresult1:
18     # 使用Match得到分组信息
19     print result1.group()
20 else:
21     print'1匹配失败！'
22  
23  
24 #若是2匹配成功
25 ifresult2:
26     # 使用Match得到分组信息
27     print result2.group()
28 else:
29     print'2匹配失败！'
30  
31  
32 #若是3匹配成功
33 ifresult3:
34     # 使用Match得到分组信息
35     print result3.group()
36 else:
37     print'3匹配失败！'
38  
39 #若是4匹配成功
40 ifresult4:
41     # 使用Match得到分组信息
42     print result4.group()
43 else:
44     print'4匹配失败！'

#运行结果

hello
hello
3匹配失败！
hello

　　

匹配分析

1.第一个匹配，pattern正则表达式为’hello’，咱们匹配的目标字符串string也为hello，从头到尾彻底匹配，匹配成功。

2.第二个匹配，string为helloo CQC，从string头开始匹配pattern彻底能够匹配，pattern匹配结束，同时匹配终止，后面的o CQC再也不匹配，返回匹配成功的信息。

3.第三个匹配，string为helo CQC，从string头开始匹配pattern，发现到 ‘o’ 时没法完成匹配，匹配终止，返回None

4.第四个匹配，同第二个匹配原理，即便遇到了空格符也不会受影响。

咱们还看到最后打印出了result.group()，这个是什么意思呢？下面咱们说一下关于match对象的的属性和方法
Match对象是一次匹配的结果，包含了不少关于这次匹配的信息，可使用Match提供的可读属性或方法来获取这些信息。

属性：
1.string: 匹配时使用的文本。
2.re: 匹配时使用的Pattern对象。
3.pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
4.endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
5.lastindex: 最后一个被捕获的分组在文本中的索引。若是没有被捕获的分组，将为None。
6.lastgroup: 最后一个被捕获的分组的别名。若是这个分组没有别名或者没有被捕获的分组，将为None。

方法：
1.group([group1, …]):
得到一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可使用编号也可使用别名；编号0表明整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了屡次的组返回最后一次截获的子串。
2.groups([default]):
以元组形式返回所有分组截获的字符串。至关于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
3.groupdict([default]):
返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
4.start([group]):
返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
5.end([group]):
返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
6.span([group]):
返回(start(group), end(group))。
7.expand(template):
将匹配到的分组代入template中而后返回。template中可使用\id或\g、\g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第10个分组，若是你想表达\1以后是字符’0’，只能使用\g0。

下面咱们用一个例子来体会一下  

 1 # -*- coding: utf-8 -*-
 2 #一个简单的match实例
 3  
 4 import re
 5 # 匹配以下内容：单词+空格+单词+任意字符
 6 m=re.match(r'(\w+) (\w+)(?P<sign>.*)','hello world!')
 7  
 8 print"m.string:",m.string
 9 print"m.re:",m.re
10 print"m.pos:",m.pos
11 print"m.endpos:",m.endpos
12 print"m.lastindex:",m.lastindex
13 print"m.lastgroup:",m.lastgroup
14 print"m.group():",m.group()
15 print"m.group(1,2):",m.group(1,2)
16 print"m.groups():",m.groups()
17 print"m.groupdict():",m.groupdict()
18 print"m.start(2):",m.start(2)
19 print"m.end(2):",m.end(2)
20 print"m.span(2):",m.span(2)
21 printr"m.expand(r'\g \g\g'):",m.expand(r'\2 \1\3')
22  
23 ### output ###
24 # m.string: hello world!
25 # m.re: 
26 # m.pos: 0
27 # m.endpos: 12
28 # m.lastindex: 3
29 # m.lastgroup: sign
30 # m.group(1,2): ('hello', 'world')
31 # m.groups(): ('hello', 'world', '!')
32 # m.groupdict(): {'sign': '!'}
33 # m.start(2): 6
34 # m.end(2): 11
35 # m.span(2): (6, 11)
36 # m.expand(r'\2 \1\3'): world hello!

 

（2）re.search(pattern, string[, flags])

search方法与match方法极其相似，区别在于match()函数只检测re是否是在string的开始位置匹配，search()会扫描整个string查找匹配，match（）只有在0位置匹配成功的话才有返回，若是不是开始位置匹配成功的话，match()就返回None。一样，search方法的返回对象一样match()返回对象的方法和属性。咱们用一个例子感觉一下 

 1 #导入re模块
 2 import re
 3  
 4 # 将正则表达式编译成Pattern对象
 5 pattern=re.compile(r'world')
 6 # 使用search()查找匹配的子串，不存在能匹配的子串时将返回None
 7 # 这个例子中使用match()没法成功匹配
 8 match=re.search(pattern,'hello world!')
 9 ifmatch:
10     # 使用Match得到分组信息
11     print match.group()
12 ### 输出 ###
13 # world

（3）re.split(pattern, string[, maxsplit])

按照可以匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将所有分割。咱们经过下面的例子感觉一下。 

1 import re
2  
3 pattern=re.compile(r'\d+')
4 print re.split(pattern,'one1two2three3four4')
5  
6 ### 输出 ###
7 # ['one', 'two', 'three', 'four', '']

（4）re.findall(pattern, string[, flags])

搜索string，以列表形式返回所有能匹配的子串。咱们经过这个例子来感觉一下 

1 import re
2  
3 pattern=re.compile(r'\d+')
4 print re.findall(pattern,'one1two2three3four4')
5  
6 ### 输出 ###
7 # ['1', '2', '3', '4']

（5）re.finditer(pattern, string[, flags])

搜索string，返回一个顺序访问每个匹配结果（Match对象）的迭代器。咱们经过下面的例子来感觉一下 

1 import re
2  
3 pattern=re.compile(r'\d+')
4 forminre.finditer(pattern,'one1two2three3four4'):
5     printm.group(),
6  
7 ### 输出 ###
8 # 1 2 3 4

（6）re.sub(pattern, repl, string[, count])

使用repl替换string中每个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可使用\id或\g、\g引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时所有替换。  

 1 import re
 2  
 3 pattern=re.compile(r'(\w+) (\w+)')
 4 s='i say, hello world!'
 5  
 6 print re.sub(pattern,r'\2 \1',s)
 7  
 8 def func(m):
 9     returnm.group(1).title()+' '+m.group(2).title()
10  
11 print re.sub(pattern,func,s)
12  
13 ### output ###
14 # say i, world hello!
15 # I Say, Hello World!

（7）re.subn(pattern, repl, string[, count])

返回 (sub(repl, string[, count]), 替换次数)。

 1 import re
 2  
 3 pattern=re.compile(r'(\w+) (\w+)')
 4 s='i say, hello world!'
 5  
 6 print re.subn(pattern,r'\2 \1',s)
 7  
 8 def func(m):
 9     returnm.group(1).title()+' '+m.group(2).title()
10  
11 print re.subn(pattern,func,s)
12  
13 ### output ###
14 # ('say i, world hello!', 2)
15 # ('I Say, Hello World!', 2)

 

5.Python Re模块的另外一种使用方式

在上面咱们介绍了7个工具方法，例如match，search等等，不过调用方式都是 re.match，re.search的方式，其实还有另一种调用方式，能够经过pattern.match，pattern.search调用，这样调用便不用将pattern做为第一个参数传入了，你们想怎样调用皆可。

函数API列表

 

1 2 3 4 5 6 7

match ( string [ , pos [ , endpos ] ] ) | re . match ( pattern , string [ , flags ] ) search ( string [ , pos [ , endpos ] ] ) | re . search ( pattern , string [ , flags ] ) split ( string [ , maxsplit ] ) | re . split ( pattern , string [ , maxsplit ] ) findall ( string [ , pos [ , endpos ] ] ) | re . findall ( pattern , string [ , flags ] ) finditer ( string [ , pos [ , endpos ] ] ) | re . finditer ( pattern , string [ , flags ] ) sub ( repl , string [ , count ] ) | re . sub ( pattern , repl , string [ , count ] ) subn ( repl , string [ , count ] ) | re . sub ( pattern , repl , string [ , count ] )