目录：

1. 正则表达式常用方法
2. 编译正则表达式
3. flags控制匹配方式
4. (?)参数
5. 匹配模式
6. 举例

import re#正则表达式
#正则表达式常用方法
match_result=re.match(pattern,string,flags)#以pattern正则表达式从string起始位置匹配 只返回一个 无匹配结果返回None
search_result=re.search(pattern,string,flags)#以pattern正则表达式搜索string直到找到一个匹配 只返回一个 无匹配结果返回None
sub_result=re.sub(pattern,substitute,string,count,flags)#以pattern正则表达式搜索string 找到一个匹配 将匹配字符串替换为substitute 无匹配结果返回None 替换count次 默认全部替换 substitute可以是函数
split_result=re.split(pattern,string,count,flags)#以pattern正则表达式匹配string后返回列表
def multiply_2(matched):return str(int(matched.group('value')) * 2)
'A46G8HFD1134'==re.sub(r'(?P<value>\d+)', multiply_2, 'A23G4HFD567')#将字符串中的数字x2

#编译正则表达式
regex_pattern=re.compile(pattern,flags)#生成一个正则表达式
match_result=regex_pattern.match(string,start_index,end_index)#返回一个match对象
fullmatch_result=regex_pattern.fullmatch(string,start_index,end_index)#整个 string 匹配正则表达式 才返回 否则返回None
match_result.group(index)#返回匹配组 0表示所有分组组成的字符 group从1开始
match_result.start()#返回匹配结果第一个字符在string的索引
match_result.end()#返回匹配结果最后一个字符在string的索引
match_result.span()#返回(start_index,end_index)
search_result=regex_pattern.search(string,start_index,end_index)#返回一个search对象 用法同match对象
findall_result=regex_pattern.findall(string,start_index,end_index)#返回所有匹配组成的列表 匹配所有 如果没有匹配返回空列表 如果正则表达式分组 返回由分组组成的每个元组组成的列表
finditer_result=regex_pattern.finditer(string,start_index,end_index)#和findall类似 但返回迭代器
sub_result=regex_pattern.sub(substitute,string,count,flags)#将匹配字符串替换为substitute后返回string 无匹配结果返回原string 替换count次 默认全部替换 substitute可以是函数
subn_result=regex_pattern.subn(substitute,string,count,flags)#和 sub类似 但返回元组 (string,count)
escape_result=regex_pattern.escape(pattern)#转义pattern中具有正则表达式特殊含义的字符
'|'.join(map(re.escape, sorted(['+', '-', '*', '/', '**'], reverse=True)))==r'/|\-|\+|\*\*|\*'

#flags控制匹配方式
re.I#re.IGNORECASE 忽略字母大小写
re.A#re.ASCII 只匹配ASCII字符
re.DEBUG#显示编译时的debug信息
re.L#re.LOCALE 基本没用 只能对byte样式有效 由当前语言区域决定 \w, \W, \b, \B 和大小写敏感匹配
re.M#re.MULTILINE 使^除了匹配整个字符串的起始位置，还匹配换行符\n后面的位置 $除了匹配整个字符串的结束位置，还匹配换行符\n前面的位置
re.S#re.DOTALL 使 . 能够匹配所有字符
re.X#re.VERBOSE 忽略表达式中的空白 和 #注释 让长正则表达式易于理解
verbose_regex = re.compile(
r'''( (\d{3}|\(\d{3}\))?    # area code
(\s|-|\.)?                  # separator
\d{3}                       # first 3 digits
(\s|-|\.)                       # separator
\d{4}                       # last 4 digits
)''',re.X)
re.findall(r'^This.*?line.$', 'This is the first line.\nThis is the second line.\nThis is the third line.', flags=re.M+re.S)==['This is the first line.', 'This is the second line.', 'This is the third line.']#匹配多行文本的每一行
flags=re.M | re.S#另一种flags表示
re.findall(r'(?ms)^This.*?line.$')#另一种flags表示 这种表达方式不需要写flags 但必须在表达式开头用(?)声明 可选参数有(?aiLmsux)

#(?)参数
(str)#分组 索引从1开始 0表示所有组组成的字符串
(?aiLmsx)#字母分别代表 re.A I L M S X 必须在表达式开头使用
(?:str)#在使用group之类的函数时忽略该组
(?P<group_name>str)#为该组命名 使用groupdict()时键为group_name 值为匹配的组
(?P=group_name)#引用(?P<group_name>str)
(?#str)#str会被忽略 当作注释
(?=str)#只有匹配到str的时候 才会匹配(?=str)前面的表达式
(?!str)#只有没有匹配到str的时候 才会匹配(?!str)前面的表达式
(?<=str)#在字符串非开始位置匹配以str开头的字符串 只能是明确的长度 可以理解成 ^str 在字符串非开始位置匹配符合字符
(?<!str)#在字符串非开始位置匹配不以str开头的字符串 只能是明确的长度 可以理解成 ^str 在字符串非开始位置匹配不符合字符
(?(group_index/group_name)yes-pattern|no-pattern)#如果给定的 group_index 或 group_name 存在，将会尝试匹配 yes-pattern ，否则就尝试匹配 no-pattern，no-pattern 可选，也可以被忽略。比如，
r'(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$)'#是一个email样式匹配，将匹配 '<user@host.com>' 或 'user@host.com' ，但不会匹配 '<user@host.com' ，也不会匹配 'user@host.com>'
match_result.group()#返回匹配的整个结果
match_result.group(int)#返回匹配结果的第int组 从1开始
match_result.groups()#返回匹配的所有组
match_result.groupdict()#返回匹配的所有组名和组组成的字典 键为组名 值为匹配的组

#匹配模式
r'pattern'#r表示忽略转义字符 写正则表达式加上就行
贪婪模式#有多种匹配字符串符合正则表达式 匹配字符串最长的 默认模式
非贪婪模式#有多种匹配字符串符合正则表达式 匹配字符串最短的 用?在正则式结尾修饰 如 .*?
'^str'#只匹配以str开头的字符串 caret ^必须在$之前 caret before dollar ==abcd
'str$'#只匹配以str结尾的字符串 dollar ^必须在$之前 caret before dollar ==abcd
.#匹配任意一个除了\n的字符 当re.M标记被指定时 则可以匹配包括换行符的任意字符
[str]#匹配在[]的一个字符 如[amk] 匹配 'a' 'm'或'k'
[^str]#不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符
(str)*#匹配0个到n个str 贪婪模式
(str)*?#匹配0个到n个str 非贪婪模式
(str)+#匹配1个到n个str 贪婪模式
(str)+?#匹配1个到n个str 非贪婪模式
(str)?#匹配时str可有可无 贪婪模式
(str)??#匹配时str可有可无 非贪婪模式 即匹配结果为空 ""
(str){ x}#只匹配重复x次的str 例如  (o){2} 不能匹配 "Bob" 中的 "o" 但是能匹配 "food" 中的两个 o
(str){ x,}#只匹配重复x次到n次的str 例如  o{2,} 不能匹配"Bob"中的"o" 但能匹配 "foooood"中的所有 o        "o{1,}" 等价于 "o+"            "o{0,}" 则等价于 "o*"
(str){ ,y}#只匹配重复0次到y次的str 例如  o{2,} 不能匹配"Bob"中的"o" 但能匹配 "foooood"中的所有 o        "o{1,}" 等价于 "o+"            "o{0,}" 则等价于 "o*"
(str){ x, y}#只匹配重复x到y次的str 贪婪模式
(str){ x, y}?#只匹配重复x到y次的str 非贪婪模式 或 str可有可无
a|b#匹配a或b

r'\w' #匹配一个字母数字及下划线 [A-Za-z0-9_] word：3rd-Person
r'\W'#匹配一个非字母数字及下划线 '[^A-Za-z0-9_]'
r'\s'#匹配一个任意空白字符 等价于  [ \f\n\r\t\v]
r'\S'#匹配一个任意非空字符 [^ \f\n\r\t\v]
r'\d'#匹配一个任意数字 等价于 [0-9].
r'\D'#匹配一个任意非数字 [^0-9]
r'\A'#类似^ 但不受re.M控制
r'\Z'#类似$ 但不受re.M控制
r'\z'#匹配一个字符串结束
r'\G'#匹配一个最后匹配完成的位置
'\b'#匹配一个单词边界 如 r'\bfoo\b' 匹配 'foo', 'foo.', '(foo)', 'bar foo baz' 但不匹配 'foobar' 或者 'foo3'
r'\B'#匹配非单词边界 如 r'py\B' 匹配 'python', 'py3', 'py2', 但不匹配 'py', 'py.', 或者 'py!'. \B 是 \b 的取非
'\n'#匹配一个换行符
'\t'#匹配一个制表符
'\1'-'\99'#第1-99个分组的内容 表达式自身也可以引用
re.compile(r'Agent (\w)\w*').sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a spy.')=='A**** told C**** that E**** knew B**** was a spy.'

[0-9]#匹配任何数字 类似于 [0123456789]
[a-z]   #匹配任何小写字母
[A-Z]#匹配任何大写字母
[a-zA-Z0-9]#匹配任何字母及数字
[^aeiou]#除了aeiou字母以外的所有字符
[^0-9]#匹配除了数字外的字符

r'\d(.*) are (.*?) .*'
r 表示忽略转义字符
(.*) 第一个匹配分组，.* 代表匹配除之外的所有长度的字符
(.*?) 第二个匹配分组，.*? 后面多个问号，代表非贪婪模式，只匹配符合条件的最少字符
re.compile(r'<.*?>').search('<To serve man> for dinner.>').group()=='<To serve man>'
re.compile(r'<.*>').search('<To serve man> for dinner.>').group()=='<To serve man> for dinner.>'

#常用正则表达式 https://www.cnblogs.com/magicking/p/8986869.html