Python学习笔记八（re模块）

re模块提供了对正则表达式的支持。以下是学习re模块过程整理的东西：模块re重要的函数方法正则表达式等

re模块重要函数	描述 [flags : 可选，表示匹配模式，比如忽略大小写，多行模式等]
compile(pattern[, flags=0])	函数编译一个正则表达式模式，返回一个模式对象re.Pattern
match(pattern, string[, flags=0])	在给定字符串string开头查找与正则表达式pattern匹配的子串,匹配成功，则返回一个Match对象，否则返回一个None；不要求模式与整个字符串匹配
search(pattern, string[, flags=0])	在给定字符串string中查找第一个与制定正则表达式pattern匹配的子串,匹配成功，则返回一个Match对象，否则返回一个None
split(pattern, string[, maxsplit=0, flags=0])	根据与模式pattern匹配的子串来分割字符串string，返回一个列表list;参数maxsplit指定最多分割多少次
findall(pattern, string[, flags=0])	返回一个列表，其中包含字符串string中所有与给定模式pattern匹配的子串
finditer(pattern, string[, flags=0])	和findall类似，在字符串string中找到正则表达式pattern所匹配的所有子串，并把它们作为一个迭代器返回callable_iterator
sub(pattern, repl, string[, count=0, flags=0])	从左往右将字符串string中与模式pattern匹配的子串替换为指定内容repl;参数count指定最多匹配替换次数
escape(string)	工具函数，将字符串string中所有可能被视为正则表达式运算符的字符进行转义

re模块重要函数修饰符-可选标志flags	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响字符串开头匹配符 ^ 和字符串末尾匹配符 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

import re

# compile(pattern[, flags]):函数编译一个正则表达式模式，返回一个模式对象re.Pattern
Pattern = re.compile(r'.')
print(Pattern,type(Pattern))

# match(pattern, string[, flags]):在给定字符串string开头查找与正则表达式pattern匹配的子串,匹配成功，则返回一个Match对象，否则返回一个None；
e=re.match(Pattern,'rsdgd')
print(e,type(e))
e=re.match('s','rsdgd')#'s'与'rsdgd'字符串第一位是否匹配
print(e,type(e))
e=re.match('.s','rsdgd')#'.s'与'rsdgd'字符串前两位是否匹配
print(e,type(e))
e=Pattern.match('rsdgd')
print(e,type(e))
Pattern = re.compile(r'(.*)')
e2=Pattern.match('rsdgd3iiigydthuh',3,12)# 从索引为3的位置开始匹配,到索引为12的位置结束，返回子串不包含索引12
print(e2,type(e2))
Pattern = re.compile(r'(.{3})')
e3=Pattern.match('rsdgd3iiigydthuh',3,6)# 从索引为3的位置开始匹配,到索引为12的位置结束，返回子串不包含索引12
print(e3,type(e3))
Pattern = re.compile(r'(.{3})')
e3=Pattern.match('rsdgd3iiigydthuh',3,6)# 从索引为3的位置开始匹配,到索引为12的位置结束，返回子串不包含索引12
print(e3,type(e3))
Pattern = re.compile(r'([a-z]+)', re.I)#re.I忽略大小写
e=Pattern.match('HowoldAr123eYou')
print(e,type(e))
e=re.match('(.)g', '\ngqwqw\ndxas\ngdf\nasdf', flags=re.M|re.S)#re.M多行匹配，影响字符串开头匹配符 ^ 和字符串末尾匹配符 $
print(e,type(e))
e=re.match('(.)+f$', '\ngqwqw\ndxas\ngdf\nasdf', re.M|re.S)#match函数，模式末尾加上$符，要求与整个字符串匹配
print(e,type(e))
e=re.match('.*', '\ngqwqw\ndxas\nadf\tasdf', flags=re.S)#re.S使'.'匹配包括换行在内的所有字符
print(e,type(e))

# search(pattern, string[, flags])：在给定字符串string中查找第一个与制定正则表达式pattern匹配的子串,匹配成功，则返回一个Match对象，否则返回一个None
Pattern = re.compile(r'.y')
e=re.search(Pattern,'rsdgd')
print(e,type(e))
e=re.search(Pattern,'Python')
print(e,type(e))
e=Pattern.search('Python')
print(e,type(e))
e=re.search('t.','PythonPytn')
print(e,type(e))
Pattern = re.compile(r'([a-z]+)', re.I)#re.I忽略大小写
e=Pattern.search('HowoldAr123eYou')
print(e,type(e))
e=re.search('^g', '\ngqwqw\ndxas\nadf\nasdf', flags=re.M)#re.M多行匹配，影响字符串开头匹配符 ^ 和字符串末尾匹配符 $
print(e,type(e))
e=re.search('f$', '\ngqwqw\ndxas\nadf\nasdf', flags=re.M)
print(e,type(e))
e=re.search('.*', '\ngqwqw\ndxas\nadf\tasdf', flags=re.S)#re.S使'.'匹配包括换行在内的所有字符
print(e,type(e))
# split(pattern, string[, maxsplit=0, flags]):根据与模式pattern匹配的子串来分割字符串string，返回一个列表list;参数maxsplit指定最多分割多少次
Pattern = re.compile(r',')
string='python,java,c,c++,c#,php,spring'
e=re.split(Pattern,string)
print(e,type(e))
e=re.split(',.',string,maxsplit=2)
print(e,type(e))
e=Pattern.split(string,maxsplit=3)
print(e,type(e))

# findall(pattern, string[, flags])：返回一个列表，其中包含字符串string中所有与给定模式pattern匹配的子串
Pattern = re.compile(r',..')
string='python,java,c,c++,c#,php,spring'
e=re.findall(Pattern,string)
print(e,type(e))
e=re.findall(r'(,.{3})',string)
print(e,type(e))
e=re.findall(r'(.{3})',string)
print(e,type(e))
e=Pattern.findall(string)
print(e,type(e))

# finditer(pattern, string[, flags])：和findall类似，在字符串string中找到正则表达式pattern所匹配的所有子串，并把它们作为一个迭代器返回callable_iterator。
Pattern = re.compile(r',..')
string='python,java,c,c++,c#,php,spring'
e=re.finditer(Pattern,string)
print(e,type(e))
for i in e:
    print(i)
e=Pattern.finditer(string)
print(e,type(e))

# sub(pattern, repl, string[, count=0, flags])：从左往右将字符串string中与模式pattern匹配的子串替换为指定内容repl;参数count指定最多匹配替换次数
Pattern = re.compile(r',..')
string='python,java,c,c++,c#,php,spring'
e=re.sub(Pattern,';zs',string)
print(e,type(e))
e=re.sub(Pattern,';zs',string,count=2)
print(e,type(e))
e=Pattern.sub(';zs',string,count=2)
print(e,type(e))

# escape(string)：工具函数，将字符串string中所有可能被视为正则表达式运算符的字符进行转义
string='python/java/c/c++/c#/php/spring'
e=re.escape(string)
print(e,type(e))

re匹配对象的重要方法 （查找与模式匹配的子串的函数都在找到时返回Match对象）	描述 [编组：放在圆括号内的子模式，根据左边的括号数编号]
group([group1,...])	获取与给定子模式（编组[group1,...]）匹配的子串，默认为0,即整个模式；多个编组时返回一个元组
start([group])	返回与给定编组[group]匹配的子串的起始索引（子串第一个字符的索引），默认为0,即整个模式
end([group])	返回与给定编组[group]匹配的子串的终止索引（子串最后一个字符的索引+1），默认为0,即整个模式
span([group])	返回一个元组（起始索引，终止索引），包含返回与给定编组[group]匹配的子串的起始索引和终止索引，默认为0,即整个模式

import re
#查找与模式匹配的子串的函数都在找到时返回Match对象
Pattern = re.compile(r'(w{3})\.(.*)\.(.{3})')
e=re.match(Pattern,'www.python.com')
print(e,type(e))
print(e.group())
print(e.group(1))
print(e.group(2,3))
print(e.start())
print(e.start(2))
print(e.end())
print(e.end(2))
print(e.span())
print(e.span(2))
Pattern = re.compile(r'(src="(www\.(.*?)\.com)")')
e=re.search(Pattern,'src="www.python.com"')
print(e,type(e))
print(e.group())
print(e.group(1))
print(e.group(2,3))
print(e.start())
print(e.start(2))
print(e.end())
print(e.end(2))
print(e.span())
print(e.span(2))

最后是常用的正则表达式模式:

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'，字符集只能匹配一个字符
[^...]	匹配不在[]中的字符，例：[^abc] 匹配除了a,b,c之外的字符
-	连字符，[a-z]与小写字母的任何字母有匹配，[a-zA-Z0-9]与小写字母、大写字母和数字都匹配
(pattern)*	pattern可重复0、1或多次
(pattern)+	pattern可重复1或多次
(pattern)?	表示可选，可选的子模式可出现一次，也可不出现
(pattern){n}	pattern重复n次
(pattern){n,}	pattern重复n或更多次
(pattern){m,n}	pattern重复m-n次
a|b	二选一的特殊字符：管道符
(pattern)	(子模式)放在圆括号内
\	转义符反斜杠，'python\\.org'或者r'python\.org'与'python.org'匹配
\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	匹配一个换行符