python_正则表达式学习

---

re.match()函数：

函数语法： re.mathch ( pattern , string , flags = 0)

参数说明：

pattem	匹配的正则表达式
string	要匹配的字符串
flags	标志位，用于控制正则的匹配方式；如大小写区分，多行匹配等

匹配成功 re.match 方法返回一个匹配的对象（object），否则返回None

可以使用group(num)或groups()匹配对象函数来获取匹配表达式

group(num)	匹配整个表达式的字符串，可以一次输入多个组号，在这种情况下将返回一个包含那些组所对应值得元组
group( )	返回一个包含那些小组字符串得元组，从1到所含得小组号

实例：

>>> import re

>>> print(re.match('www','www.google.com').span())  #在起始位匹配

(0, 3)

>>> print(re.match('com','www.google.com'))#不在起始位匹配

None

实例：

>>> import re

>>> line = "Cats are smarter than dogs"

>>> # .* 表示任意匹配除换行符（\n \r）之外的任何单个或多个字符

>>> match0bj = re.match(r'(.*)are(.*?).*',line,re.M|re.I)

>>> if match0bj:

print('match0bj.group():',match0bj.group())

print('match0bj.group(1):',match0bj.group(1))

print('match0bj.group(2):',match0bj.group(2))

>>> else:

print('No match!!!')

match0bj.group(): Cats are smarter than dogs

match0bj.group(1): Cats

match0bj.group(2): 

re.search()函数：扫描整个字符串并返回第一个成功的匹配

函数语法： re.search( pattern , string , flags=0 )

参数说明：

pattem	匹配的正则表达式
string	要匹配的字符串
flags	标志位，用于控制正则的匹配方式；如大小写区分，多行匹配等

匹配成功 re.match 方法返回一个匹配的对象（object），否则返回None

可以使用group(num)或groups()匹配对象函数来获取匹配表达式

group(num)	匹配整个表达式的字符串，可以一次输入多个组号，在这种情况下将返回一个包含那些组所对应值得元组
group( )	返回一个包含那些小组字符串的元组，从1到所含得小组号

实例：

>>> import re

>>> print(re.search('www','www.google.com').span())#在起始位匹配

(0, 3)

>>> print(re.search('com','www.google.com'),span())#不在起始位匹配

(11, 14)

re.match与re.search的区别：

re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而 re.search匹配整个字符串，直到找到一个匹配。

>>> import re

>>> line = 'Cats are smarter than dogs'

>>> match0bj = re.match( r'dogs',line,re.M|re.I)

>>> if match0bj:

print("match --> match0bj.group():",match0bj.group())

else:

print("No match!!!")

No match!!!

>>> match0bj = re.search(r'dogs',line,re.M|re.I)

>>> if match0bj:

print("match --> match0bj.group():",match0bj.group())

else:

print("No match!!!")

match --> match0bj.group(): dogs

re.sub()函数:（检索和替换）用于替换字符串中的匹配项

语法：    re.sub( pattern , rep1 , string , coun=0 )

参数：

pattern	正则中的模式字符串
repl	替换的字符串，也可为一个函数
string	要被查找替换的原始字符串
count	模式匹配后替换的最大次数，默认0表示替换所有的匹配

实例：

>>> import re

>>> phone = '2004-959-559  # 这是一个号码'

>>> #删除注释

>>> num = re.sub (r'#.*$',"",phone)

>>> print("电话号码：",num)

电话号码： 2004-959-559  

>>> #移除非数字的内容

>>> num = re.sub(r'-',"",phone)

>>> print("电话号码：",num)

电话号码： 2004959559  # 这是一个号码

repl参数是一个函数：

>>> import re

>>> #将匹配的数字乘于 2

>>> def double(matched):

value = int(matched.group('value'))

return str(value * 2)

>>> s = 'A23G4HFD567'

>>> print(re.sub('(?P<value>\d+)',double,s))

A46G8HFD1134

re.compile()函数：

用于编译正则表达式，生成一个正则表达式（Pattern）对象，供match()和search()这两个函数使用！

语法格式：    re.compile( pattern [, flags ] )

参数：

pattem

一个字符串形式的正则表达式

flags

（可选）表示匹配模式，比如忽略大小写，多行模式等

具体参数：

re.I	忽略大小写
re.L	表示特殊字符集\w,\W,\b,\B,\s,\S 依赖当前环境
re.M	多行模式
re.S	即‘ . ’并且包括换行符在内的任意字符（‘ . ’不包括换行符）
re.U	表示特殊字符集\w,\W,\b,\B,\s,\S依赖于Unicode字符属性数据库
re.X	为了增加可读性，忽略空格和‘ # ’后面的注释

实例：

>>> import re

>>> pattern = re.compile(r'\d+')

>>> m = pattern.match('one12twothree34four') #查找头部，没有匹配

>>> print(m)

None

>>> m = pattern.match('one12twothree34four',2,10)  #从e的位置开始匹配，没有匹配

>>> print(m)

None

>>> m = pattern.match('one12twothree34four',3,10)#从1的位置开始匹配，正好匹配

>>> print(m)#返回一个 Match 对象

<_sre.SRE_Match object; span=(3, 5), match=''>

>>> m.group(0)#可省略 0

''

>>> m.start(0)#可省略 0

3

>>> m.end(0)#可省略 0

5

>>> m.span(0)#可省略 0

(3, 5)

在实例中，当匹配成功返回一个Match对象，其中：

group([group1,...])	用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用group()或group(0)
start([group])	用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符索引）默认 0
end([group])	获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1）默认0
span([group])	返回（start（group），end(group)）

实例+续

>>> import re

>>> pattern = re.compile(r'([a-z]+) ([a-z]+)',re.I)#re.I表示忽略大小写

>>> m = pattern.match('hello world wide web')

>>> print (m)#匹配成功，返回一个 Match 对象

<_sre.SRE_Match object; span=(0, 11), match='hello world'>

>>> m.group(0)#返回匹配成功的整个字符串

'hello world'

>>> m.span()#返回匹配成功的整个子串的索引

(0, 11)

>>> m.group(1)#返回第一个分组匹配成功的子串

'hello'

>>> m.span (1)#返回第一个分组匹配成功的子串的索引

(0, 5)

>>> m.group(2)#返回第二个分组匹配成功的子串

'world'

>>> m.span (2)#返回第二个分组匹配成功的子串的索引

(6, 11)

>>> m.groups()#等价于 (m.group(1),m.group(2), ...)

('hello', 'world')

>>> m.group(3)#不存在第三个分组——报错error

Traceback (most recent call last):

  File "<pyshell#12>", line 1, in <module>

    m.group(3)

IndexError: no such group

findall()函数：

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的则返回空list。

注意：match和search是匹配一次/findall匹配所有。

语法格式：    findall( string[, pos[, endpos]])

参数：

string	待匹配的字符串
pos	可选参数，指定字符串的起始位置（默认 0）
endpos	可选参数，指定字符串的结束位置，（默认字符串总长度）

实例：

>>> import re

>>> pattern = re.compile(r'\d+') #查找数字

>>> result1 = pattern.findall('runoob 123 google 456')

>>> result2 = pattern.findall('run88oob123google456',0,10)

>>> print(result1)

['', '']

>>> print(result2)

['', '']

re.finditer()函数：

——和findall类似，在字符串中找到正则表达式所匹配的所有子串，并把他们作为一个迭代器返回。

语法格式：    re.finditer( pattern, string, flags=0 )

参数:

pattern	匹配的正则表达式
string	要匹配的字符串
flags	标志位

实例：

>>> import re

>>> it = re.finditer(r'\d+','12a32bc43jf3')

>>> for match in it:

print(match.group())

12

32

43

3

re.split()函数：

split方法按照能够匹配的子串将字符串分割后返回列表list，语法如下：

　　re.split( pattern, string[,maxsplit=0, flags=0])

参数：

pattern	匹配的正则表达式
string	要匹配的字符串
maxsplit	分隔次数，maxsplit=1>>分隔一次，默认为0 不限次数
flags	标志位

实例：

>>>import re

>>> re.split('\W+', 'runoob, runoob, runoob.')

['runoob', 'runoob', 'runoob', '']

>>> re.split('(\W+)', ' runoob, runoob, runoob.')

['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']

>>> re.split('\W+', ' runoob, runoob, runoob.', 1)

['', 'runoob, runoob, runoob.']

>>> re.split('a*', 'hello world') #对于一个找不到匹配的字符串而言，split 不会对其作出分割

['hello world']

正则表达式对象：

·re.compile() 返回 RegexObject 对象

·re.MatchObject

group()返回被RE匹配的字符串

——start() :返回匹配开始的位置

—— end() :返回匹配结束的位置

——span() :返回一个元组包含匹配（开始，结束）的位置

正则表达式修饰符——可选标志：

正则表达式可以包含一些可选标志修饰符来控制匹配的模式；修饰符被指定为一个可选的标志；多个标志可 以通过按位 OR（I）它们来指定。（如re.I | re.M 被设置成I和M标志）：

修饰符	作用
re.I	使匹配大小写不敏感（忽略大小写）
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响  ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写的更易于理解

正则表达式模式：

·模式字符串使用特殊的语法来表示一个正则表达式；

·字母和数字表示他们自身；一个正则表达式模式中的字母和数字匹配同样的字符串；

·多数字母和数字前加一个反斜杠时会拥有不同的含义；

·标点符号只有被转义时才匹配自身，否则它们表示特殊的含义；

·反斜杠本身需要使用反斜杠转义；

·由于正则表达式通常都包含反斜杠，所以你最好使用原始的字符串来表示它们。

·模式元素： r'\t' 等价于 \\t  匹配相应的特殊字符；

·下表列出了re表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式 元素的含义会该改变：

模式	作用
^	匹配字符串的开头
$	匹配任意字符，除了换行符，当DOTALL标记被指定时，则可以匹配包括换行符的任意字符
[...]	用来表示一组字符，单独列出：[amk]匹配’a’,’m’或’k’
[^...]	不在[]中的字符：[^abc]匹配除了a,b,c之外的字符
re*	匹配0个或多个的表达式
re+	匹配1个或多个的表达式
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	匹配n个前面表达式（例如：”o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的“o”）
re{ n,}	精确匹配n个前面表达式。例如，"o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。
re{n,m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a|b	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i,m或x —只影响括号中的区域
(?-imx)	正则表达式关闭i，m，或x可选标志
(?:re)	类似（...），但是不表示一个组
(?imx:re)	在括号内使用i，m，x 可选标志
(?-imx:re)	在括号内不使用i，m，x 可选标志
(?#...)	注释
(?=re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边
(?!re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
(?>re)	匹配的独立模式，省去回溯。
\w	匹配数字字母下划线
\W	匹配非数字字母下划线
\s	匹配任意空白字符（等价于\t \n \r \f）
\S	匹配任意非空字符
\d	匹配任意数字（等价于[0-9]）
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束（如果存在换行，只匹配到换行前的结束字符）
\z	匹配字符串结束
\G	匹配最后匹配完成的位置
\b	匹配一个单词边界，也就是指单词和空格间的位置（例如：‘er\b’可以匹配“never”中的‘er’但不能匹配“verb”中的‘er’
\B	匹配非单词边界（例如：'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'）
\n \t 等	匹配一个换行符，匹配一个制表符等
\1...\9	匹配第n个分组的内容
\10	匹配第n个分组的内容，如果它经匹配；否则指的时八进制字符码的表达式

正则表达式实例：

字符匹配：

[Pp]ython	匹配“Python”或“python”
rub[ye]	匹配“ruby”或“rube”
[aeiou]	匹配中括号内任意一个字母
[0-9]	匹配任何数字
[a-z]	匹配任何小写字母
[A-Z]	匹配任何大写字母
[a-zA-Z0-9]	匹配任何数字和字母
[^aeiou]	除了aeiou字母以外的所有字符
[^0-9]	匹配除了数字以外的字符

特殊字符类：

.	匹配除“\n”之外的任何单个字符，匹配“\n”之内的使用“ [.\n] ”模式
\d	匹配一个数字字符
\D	匹配一个非数字字符
\s	匹配任何空白字符
\S	匹配任何非空白字符
\w	匹配包含下划线的任何单词字符
\W	匹配任何非单词的字符

---