匹配星号前面字符，星号前面的字符可以没有，也可以有多个，如ab*，将修饰字符b，字符b可以没有只匹配字符a，也可以有多个b。所以ab*可以匹配“a”、“ab”或“abbbbb”后面跟着任意数量的“b”。如下:
import re
print(re.findall("ab*","ampabnabbbbq"))
#
打印结果：
[
'a'
,
'ab'
,
'abbbb'
]
" + "
匹配+号前字符出现的次数，如ab+，会匹配ab，和ab加上任意数量的b，如abbbb
import re
print(re.findall("ab+","apabnabbbbq"))
#
打印结果：
[
'ab'
,
'abbbb'
]
" ? "
匹配?前字符出现的次数，字符可以是0次，最多是一次，如ab?，只能匹配a或者ab。
import re
print(re.findall("ab?","amabnabbbbq"))
#
打印结果：
[
'a'
,
'ab'
,
'ab'
]
" *? "
匹配*?前字符出现的次数，被匹配的字符可以出现0次，最多是1次。但是*?具有惰性，当匹配到第一个字符后，就不会继续在匹配。如ab*?可以匹配a或者ab，但是当出现字符a后就不会在去匹配字符b了。如下：
import re
print(re.findall("ab*?","apabcabbbbq"))
#
打印结果：
[
'a'
,
'a'
,
'a'
]
" +? "
匹配+?前字符，+?具有惰性，被匹配的字符最少出现1次，仅匹配+?前面的字符串，匹配到后就结束，不会在匹配后边的结果，如ab+?只能匹配ab，如下:
import re
print(re.findall("ab+?","apabcabbbbq"))
#
打印结果：
[
'ab'
,
'ab'
]
" ?? "
匹配??前的字符，??具有惰性，匹配到第一个字符后便不会继续向后匹配，如：ab?? 只匹配到a便结束了。
import re
print(re.findall("ab??","apabcabbbqq"))
#
打印结果：
[
'a'
,
'a'
,
'a'
]
匹配m个被修饰的字符，如ab{2}将匹配abb。如下：
import re
print(re.findall("ab{2}","apaabbcabbbbqq"))
#
打印结果：
[
'abb'
,
'abb'
]
{m,n}
匹配m到n范围内的被修饰符的个数，如ab{1,3}将匹配ab，abb，abbb
import re
print(re.findall("ab{1,3}","abmpabbcabbbbbqq"))
#
打印结果：
[
'ab'
,
'abb'
,
'abbb'
]
{m,n}?
有?号将具有惰性机制，将只能匹配到m个，如ab{1,3}?，将只能匹配ab
import re
print(re.findall("ab{1,3}?","abmpabbcabbbbbqq"))
#
打印结果：
[
'ab'
,
'ab'
,
'ab'
]
" | "
或的意思，匹配两边的字符，如a|b将匹配a或者匹配b
import re
print(re.findall("a|b","abmpabbcaqq"))
#
打印结果：
[
'a'
,
'b'
,
'a'
,
'b'
,
'b'
,
'a'
]
" ... "
将匹配引号内点数量的任意类型字，如'...'将匹配3个任意类型字符，如下：
import re
print(re.findall("...","12abmpabbcaqq"))
#打印结果：
[
'12a'
,
'bmp'
,
'abb'
,
'caq'
]
" \ "
用于表示一组字符，如[0-9]表示匹配0到9的数字，[a-z]匹配a-z的所有字符，如果带有-必须是ASCII码表中从小到大的顺序进行排列，如[9-0]是错误的。
匹配以字符串或字符开头，如下：
import re
print(re.findall("\Aab","abcdavcdsb"))
#打印结果：
[
'ab'
]
只匹配数字
import re
print(re.findall("\d"," abcd12avc4dsb "))
#打印结果：
[
'1'
,
'2'
,
'4'
]
匹配除了数字以外任意字符
import re
print(re.findall("\D","abcd12_!@#$"))
# 打印结果：
[
'a'
,
'b'
,
'c'
,
'd'
,
'_'
,
'!'
,
'@'
,
'#'
,
'$'
]
匹配空白，制表符如[" "\t\n\r\f\v]等如下：
import re
print(re.findall("\s","ab cd12a\tvc\n4dsb"))
#打印结果：
[
'
'
,
'\t'
,
'\n'
]
匹配除了空白，制表符[" "\t\n\r\f\v]以外的任意字符,，如下：
import re
print(re.findall("\S","ab 123\tv_#\n$%^"))
#打印结果：
[
'a'
,
'b'
,
'1'
,
'2'
,
'3'
,
'v'
,
'_'
,
'#'
,
'$'
,
'%'
,
'^'
]
匹配字母，数字，下划线如下：
import re
print(re.findall("\w","ab_123!@#\t&*\n"))
#打印结果：
[
'a'
,
'b'
,
'_'
,
'1'
,
'2'
,
'3'
]
匹配除了字母,数字,下划线以外的任意字符,如下:
import re
print(re.findall("\W","ab_123!@#\t&*\n"))
#打印结果：
[
'!'
,
'@'
,
'#'
,
'\t'
,
'&'
,
'*'
,
'\n'
]
re.compile(pattern, flags=0)：参数pattern是一个表达式规则，返回一个表达式对象相当于一个表达式规则模板。
import re
re_pottern = re.compile("\w")
print(re_pottern.findall("abc_$%def"))
# 打印内容如下
['a', 'b', 'c', '_', 'd', 'e', 'f']
re.search(pattern, string, flags=0)：根据表达式规则查找字符串，如果找不到匹配返回None，如果找到返回匹配到的对象。
import re
print(re.search("\w+","abc1#$%2abc3"))
# 打印内如下
<re.Match object; span=(0, 4), match='abc1'>
re.match(pattern, string, flags=0)：与search类似。
import re
print(re.match("\w+","abc1#$%2abc3"))
#打印内容如下
<re.Match object; span=(0, 4), match='abc1'>
re.split(pattern, string, maxsplit=0, flags=0)：将表达式的参数作为分隔符进行切割，返回切割后的列表。
import re
print(re.split("\W+","Words, words, words"))
# 打印内容如下
['Words', 'words', 'words']
re.findall(pattern, string, flags=0)：在整个字符串内匹配表达式，返回匹配到的结果。
import re
print(re.findall("\w","abc#$_def"))
# 打印内如如下
['a', 'b', 'c', '_', 'd', 'e', 'f']
re.finditer(pattern, string, flags=0)：匹配整个字符串，返回一个迭代器。
import re
iter_ = re.finditer("\w","abc#$_def")
print(iter_.__next__())
print(iter_.__next__())
print(iter_.__next__())
# 打印内容如下
<re.Match object; span=(0, 1), match='a'>
<re.Match object; span=(1, 2), match='b'>
<re.Match object; span=(2, 3), match='c'>
re.sub(pattern, repl, string, count=0, flags=0)：
pattern：表达式。
repl：要替换的参数。
string：要被替换的字符串。
count：替换的次数，默认替换所有。
返回一个字符串。
import re
print(re.sub("\w","a","abc#$_def"))
print(re.sub("\w","a","abc#$_def",count=2))
# 打印内容如下
aaa#$aaaa
aac#$_def
re.subn(pattern, repl, string, count=0, flags=0)：
pattern：参数是表达式。
repl：要替换的参数。
string：要被替换的字符串。
count：替换的次数，默认替换所有。
返回一个被替换后的字符串和替换次数组成的元组。
import re
print(re.subn("\w","a","abc#$_def"))
print(re.subn("\w","a","abc#$_def",count=2))
# 打印内容如下
('aaa#$aaaa', 7)
('aac#$_def', 2)
re.purge()：清空正则表达式缓存。
。。。。。。。。。。。。。。待续。。。。。。。。。。。。。。。。。。。。
下一篇：configparser 、random
