目录
1.特殊字符
| 特殊字符 | 字符说明 |
| . | 代表除换行符外的任何字符 |
| ^ | 代表字符串的开头 |
| $ | 代表字符串的结束，或者代表下一行的前面字符串 |
| * | 代表字符重复0次或多次，属于贪婪模式 |
| + | 代表字符重复1次或多次，属于贪婪模式 |
| ? | 代表字符出现0次或1次 |
| *?,+?,?? | 非贪婪模式 |
| {m,n} | 代表字符重复m到n次 |
| {m,n}? | 非贪婪模式 |
| \\ | 代表\ |
| [] | 代表[]中的一些列字符 |
| | | A|B代表A或者B |
| (...) | 组的概念，其中可以被后期获取或匹配 |
| (?aiLmsux) | 定义的标识字母 |
| (?:...) | 非分组模式 |
| (?P<name>...) | 通过名称获得组匹配的子字符串 |
| (?P=name) | 通过组名匹配之前匹配的文本 |
| (?#...) | 注释，忽略 |
| (?=...) | 正向肯定预查，匹配pattern前面的位置 |
| (?!...) | 正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串 |
| (?<=...) | 反向肯定预查，匹配pattern后面的位置 |
| (?<!...) | 正向否定预查，在任何不匹配pattern的字符串后面匹配查找字符串 |
| (?(id/name)yes|no) | 匹配yes模板，如果组的id或名字匹配，否则匹配no模板 |
2.转义字符
| 转义字符 | 字符说明 |
| \number | 匹配组中具有相同数字的内容 |
| \A | 只匹配字符串的开头 |
| \Z | 只匹配字符串的结尾 |
| \b | 匹配空字符，只限定与单词的开头或结尾 |
| \B | 匹配空字符，但不在单词的开头或结尾 |
| \d | 匹配任何数字；和[0-9]规则等同 |
| \D | 匹配非数字的字符；和[^0-9]规则等同 |
| \s | 匹配所有的空白字符;等同规则[\t\n\r\f\v] |
| \S | 匹配所有非空白的字符；等同规则[^\s] |
| \w | 匹配所有文字和数字字符；等同规则[a-zA-z0-9] |
| \W | 等同规则\w |
| \\ | 匹配\ |
3.常用方法
| 函数 | 函数说明 |
| match(pattern,string,flags=0) | 在字符串开头运用正则； 返回结果为Match对象，没有匹配时返回None |
| fullmatch(pattern,string,flags=0) | 对整个字符串运用正则 返回结果为Match对象，没有匹配时返回None |
| search(pattern,string,flags=0) | 扫描字符串，查看符合正则的部分 返回结果为Match对象，没有匹配时返回None |
| sub(pattern,repl,string,count=0,flags=0) | 用指定的字符串替换原字符串中符合正则的部分 返回结果为替换后的字符串 |
| subn(pattern,repl,string,count=0,flag=0) | 用指定的字符串替换原字符串中符合正则的部分 返回结果为元组，元组第一个元素为替换后的字符串，元组第二个正则满足匹配的次数 |
| split(pattern,string,maxsplit=0,flags=0) | 根据正则将字符串拆分为列表 返回结果为列表，如果设定了maxsplit标识最多被分为maxsplit次 |
| findall(pattern,string,flags=0) | 查询字符串中所有符合正则的部分 返回结果为列表，列表元素为符合正则的部分。当正则中有组时，列表元素为一个个符合组的元组，元组中的元素为每个符合组的元素 |
| finditer(pattern,string,flags=0) | 返回一个Match对象的迭代器，用来获取每个匹配的对象。 |
| compile(pattern,flags=0) | 将一个模式变为一个Pattern对象 返回结果为一个Pattern对象 |
| purge() | 清空正则缓存 |
| escape(pattern) | 给所有的非字母数字字符添加反斜杠 |
4.标志符号
| 标志符号 | 标志说明 |
| re.A | 匹配ASCII字符类型 |
| re.I | 不区分大小写 |
| re.L | 让\w,\W,\b,\B满足地区特色 |
| re.M | 多行模式 |
| re.S | .特殊字符匹配所有字符 |
| re.X | 忽略空白和注释 |
| re.U | unicode编码，针对字符串有效 |
5.示例
1.match和findall的区别
#导入re包
import re
#原字符串
source ='我的电话号码是13576878907'
#match方法
patter_match ='我.{3,4}'
result_match = re.match(patter_match,source)
print("re.match方法的结果数据类型是{}".format(type(result_match)))
print("re.match方法的结果是: {}.".format(result_match))
print("Match对象对应的匹配结果是{}".format(result_match.group()))
print("*******************************************************")
patter_match_failed='\d{11}'
result_match_failed=re.match(patter_match_failed,source)
print("re.match方法的结果数据类型是{}".format(type(result_match_failed)))
print("re.match方法的结果是{}".format(result_match_failed))
print("*******************************************************")
#search方法
patter_search='\d{11}'
result_search=re.search(patter_match_failed,source)
print("re.search方法的结果数据类型是{}".format(type(result_search)))
print("re.search方法的结果是{}".format(result_search))
print("Match对象对应的匹配结果是{}".format(result_search.group()))
patter_search_failed='^你.*$'
result_search_failed=re.search(patter_search_failed,source)
print("re.search方法的结果数据类型是{}".format(type(result_search_failed)))
print("re.search方法的结果是：{}".format(result_search_failed))
print("*******************************************************")
#findall方法
result_findall=re.findall(patter_match_failed,source)
print("re.findall方法的结果数据类型是{}".format(type(result_findall)))
print("re.findall方法的结果是{}".format(result_findall))
patter_findall_failed='^你.*$'
result_findall_failed=re.findall(patter_findall_failed,source)
print("re.findall方法的结果数据类型是{}".format(type(result_findall_failed)))
print("re.findall方法的结果是：{}".format(result_findall_failed))运行结果：
re.match方法的结果数据类型是<class 're.Match'>
re.match方法的结果是: <re.Match object; span=(0, 5), match='我的电话号'>.
Match对象对应的匹配结果是我的电话号
*******************************************************
re.match方法的结果数据类型是<class 'NoneType'>
re.match方法的结果是None
*******************************************************
re.search方法的结果数据类型是<class 're.Match'>
re.search方法的结果是<re.Match object; span=(7, 18), match='13576878907'>
Match对象对应的匹配结果是13576878907
re.search方法的结果数据类型是<class 'NoneType'>
re.search方法的结果是：None
*******************************************************
re.findall方法的结果数据类型是<class 'list'>
re.findall方法的结果是['13576878907']
re.findall方法的结果数据类型是<class 'list'>
re.findall方法的结果是：[]从结果中可以看出match方法在匹配正则时，必须从文本开头开始进行查询，否则查询不到，并且match方法的返回值为Match对象，当查询不到时返回值为None。Match对象通过group方法获取的详细的匹配内容。
search方法在匹配正则时，不限制匹配的位置，返回值为Match对象，当没有内容匹配正则时，返回None。
findall方法在匹配正则时，不限制匹配的位置。返回值为列表，列表中元素是匹配的内容，当没有内容匹配正则时，返回空列表。
2.fullmatch方法的理解
import re
patter_fullmatch='我.*'
result_fullmatch=re.fullmatch(patter_fullmatch,source)
print("re.fullmatch方法的结果数据类型是{}".format(type(result_fullmatch)))
print("re.fullmatch方法的结果是{}".format(result_fullmatch))
patter_fullmatch_failed ='我.{3,4}'
result_fullmatch_failed=re.fullmatch(patter_match_failed,source)
print("re.fullmatch方法的结果数据类型是{}".format(type(result_fullmatch_failed)))
print("re.fullmatch方法的结果是{}".format(result_fullmatch_failed))运行结果：
re.fullmatch方法的结果数据类型是<class 're.Match'>
re.fullmatch方法的结果是<re.Match object; span=(0, 18), match='我的电话号码是13576878907'>
re.fullmatch方法的结果数据类型是<class 'NoneType'>
re.fullmatch方法的结果是None从结果可以看出只有正则能否完全匹配整个字符串时才会有Match对象返回值，否则返回None。
3.finditer方法的理解
#finditer方法
import re
source='我的电话号码是13576878907'
patter_finditer='\d{11}'
result_finditer=re.finditer(patter_finditer,source)
print("re.finditer方法的结果数据类型是{}".format(type(result_finditer)))
print("re.finditer方法的结果是{}".format(result_finditer))
for m in result_finditer:
print("迭代器中元素的类型是{}".format(type(m)))
print("匹配的文本起始位置{}".format(m.start()))
print("匹配的文本结束位置{}".format(m.start()))
print("匹配的文本内容是{}".format(source[m.start():m.end()]))
print("匹配的文本内容是{}".format(m.group()))运行结果：
re.finditer方法的结果数据类型是<class 'callable_iterator'>
re.finditer方法的结果是<callable_iterator object at 0x000002444AEFB670>
迭代器中元素的类型是<class 're.Match'>
匹配的文本起始位置7
匹配的文本结束位置7
匹配的文本内容是13576878907
匹配的文本内容是13576878907从结果中可以看出re.finditer方法返回的结果是一个包含Match对象的迭代器，可以通过Match对象的start和end方法求出字符串中符合正则的位置，并通过切片或者group方法求得满足正则的内容。
4.sub方法的理解
#sub方法
import re
source = '我的 电话 号码是 13576878907'
patter_sub='\s*'
result_sub=re.sub(patter_sub,'',source)
print("re.sub方法的结果数据类型是{}".format(type(result_sub)))
print("re.sub方法的结果是{}".format(result_sub))
result_sub_2=re.sub(patter_sub,'',source,count=6)
print("re.sub方法count参数的结果是{}".format(result_sub_2))运行结果
re.sub方法的结果数据类型是<class 'str'>
re.sub方法的结果是我的电话号码是13576878907
re.sub方法count参数的结果是我的电话号码是 13576878907从结果中可以看出re.sub方法返回的结果是一个替换后的字符串，count参数的作用在于限定替换前n个符合正则的内容。
5.subn方法的理解
#subn方法
import re
source = '我的 电话 号码是 13576878907'
patter_subn='\s*'
result_subn=re.subn(patter_subn,'',source)
print("re.subn方法的结果数据类型是{}".format(type(result_subn)))
print("re.subn方法的结果是{}".format(result_subn))
result_subn_2=re.subn(patter_subn,'',source,6)
print("re.subn方法的结果是{}".format(result_subn_2))运行结果：
re.subn方法的结果数据类型是<class 'tuple'>
re.subn方法的结果是('我的电话号码是13576878907', 22)
re.subn方法的结果是('我的电话号码是 13576878907', 6)从结果中可以看出re.subn方法返回的结果是一个元组，元组的第一个元素是替换后的字符串，第二个元素是正则匹配的次数。count参数的作用用于限制替换前n次正则匹配的字符。
6.split方法的理解
#split方法
source = '我的 电话 号码是 13576878907'
patter_split='\s+'
result_split=re.split(patter_split,source)
print("re.split方法的结果数据类型是{}".format(type(result_split)))
print("re.split方法的结果是{}".format(result_split))
result_subn_2=re.split(patter_split,source,maxsplit=2)
print("re.split方法的结果是{}".format(result_subn_2))运行结果：
re.split方法的结果数据类型是<class 'list'>
re.split方法的结果是['我的', '电话', '号码是', '13576878907']
re.split方法的结果是['我的', '电话', '号码是 13576878907']从结果中可以看出re.split方法的返回值为一个列表，列表中的元素是在满足正则匹配处分隔的元素。maxsplit参数的作用在于限制分隔的次数。
325
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
