引言
现在是北京时间23：09，今天学习的是正则表达式，这个前面简单，后面有点不好理解，在实际应用过程中也有些难度，明天的话，有时间就开新的知识点，没时间就联系联系正则表达式。话不多说直接开始吧。
一.正则表达式函数
在python里面，要使用正则表达式需要导入re的模块包，其中包括三个主要函数：
- match（arg，str）：在str字符串中，必须从字符串开头匹配，如果没有返回None
- search(arg,str): 在str字符串中，可以在这个字符串任意位置匹配，如果没有返回None
- finall(arg,str): 在Str字符串中，同上，但是上面只能匹配一个，这个能匹配所有符合条件的字符，并返回一个列表。通常配合re.s使用，表示字符串如果换行，就吧整个字符看作一个整体，而不是一行一行的匹配。
import re str = "hello my LIST name is LIST" res1 = re.match("h",str) res2 = re.search("LIST",str) res3 = re.finall("LIST",str) print(res1.group()) #h print(res2.group()) #LIST print(res3.group()) #[LIST,LIST]二.单字符匹配
单字符匹配都匹配单个字符数据。且开头（从字符串0位置开始）没匹配到，即使字符串其他部分包含需要匹配的内容，.match也会返回none
| . | 单个任意字符 |
| [] | 匹配到【】中的任意字符即可 |
| \d | 匹配到数字即可 |
| \D | 匹配到非数字即可 |
| \w | 匹配的单词字符，包括字母数字，下划线 |
| \W | 匹配到非字符 |
| \s | 匹配到特殊字符即可，如空格，tab键，逗号 |
| \S | 匹配到非特殊字符 |
.
匹配任意一个字符，使用几个点好就代表几个字符
import re
a = re.match('..','testasdtest')
print(a.group()) #输出te
b = re.match('ab.','testasdtest')
print(b) #返回none，因为表达式是以固定的ab开头然后跟上通配符. 所以必须要先匹配上ab才会往后进行匹配
\d
匹配数字
import re
a = re.match('\d\d','23es12testasdtest')
print(a)
b = re.match('\d\d\d','23es12testasdtest')
print(b) #要求匹配三个数字，匹配不到返回none
c = re.match('\d','es12testasdtest')
print(c) #起始位置没有匹配成功，一样返回none
\D
匹配非数字，开头没匹配到，即使字符串其他部分包含需要匹配的内容，.match也会返回none
import re
a = re.match('\D','23es12testasdtest')
print(a) #开头为数字所以返回none
b = re.match('\D\D','*es12testasdtest')
print(b) #返回*e
\s
匹配特殊字符，如空白，空格，tab等
import re
print(re.match('\s',' 23es 12testasdtest')) #匹配空格
print(re.match('\s',' 23es 12testasdtest')) #匹配tab
print(re.match('\s','\r23es 12testasdtest')) #匹配\r换行
print(re.match('\s','23es 12testasdtest')) #返回none
'
\S
匹配非空白
import re
print(re.match('\S',' 23es 12testasdtest')) #返回none
print(re.match('\S','\r23es 12testasdtest')) #none
print(re.match('\S','23es 12testasdtest'))
\w
匹配单词、字符，如大小写字母，数字，_ 下划线
import re
print(re.match('\w','23es 12testasdtest')) #返回none
print(re.match('\w\w\w','aA_3es 12testasdtest')) #返回none
print(re.match('\w\w\w','\n12testasdtest')) #返回none
'
\W
匹配非单词字符
import re
print(re.match('\W','23es 12testasdtest')) #返回none
print(re.match('\W',' 23es 12testasdtest')) #匹配空格
[ ]
匹配[ ]中列举的字符，只允许出现[]中列举的字符
import re
print(re.match('12[234]','232s12testasdtest')) #因为开头的12没匹配上，所以直接返回none
print(re.match('12[234]','1232s12testasdtest')) #返回123
[^2345]
不匹配2345中的任意一个
import re
print(re.match('12[^234]','232s12testasdtest')) #因为开头的12没匹配上，所以直接返回none
print(re.match('12[^234]','1232s12testasdtest')) #返回none
print(re.match('12[^234]','1252s12testasdtest')) #返回125
[a-z3-5]
匹配a-z或者3-5中的字符
import re
print(re.match('12[1-3a-c]','1232b12testasdtest')) #123
print(re.match('12[1-3a-c]','12b2b12testasdtest')) #12b
print(re.match('12[1-3a-c]','12s2b12testasdtest')) #返回none三.表示数量
上面的单字符匹配只能一个一个匹配，如果一个字符2000多个，我不能.2000下啊，所以现在学习一下正则表达式的数量上的匹配，其中有以下匹配符
| * | 匹配字符和前面一个一样，并且数量可以是0个或者无数个 |
| + | 同上，到那时数量至少是一个 |
| ？ | 匹配字符和前面一个字符出现1次或者0次，要么有要么没有 |
| {m} | 匹配字符和前面一个字符出现m次，不能多也不能少 |
| {m,} | 同上，但是至少m次，甚至更多 |
| {m,n} | 同上，出现次数是m到n即可 |
*
出现0次或无数次
import re
a = re.match('..','testasdtest')
print(a.group()) #输出te
a = re.match('.*','testasdtest')
print(a.group()) #全部输出
import re
print(re.match('a*','aatestasdtest')) #匹配跟随在字母a后面的所有a字符
print(re.match('\d*','23aatestasdtest')) #匹配前面为数字的字符
print(re.match('a\d*','ad23aatestasdtest')) #输出a, 因为*也可以代表0次
+
至少出现一次
import re
print(re.match('a+','aaatestasdtest')) #匹配前面为字母a的字符，且a至少有1一个
print(re.match('a+','atestasdtest')) #a
print(re.match('a+','caaatestasdtest')) #none
?
1次或则0次
import re
print(re.match('a?','abatestasdtest')) #匹配a出现0次或者1次数
print(re.match('a?','batestasdtest')) #输出空，因为a可以为0次
print(re.match('a?','aaatestasdtest')) #a出现0次或者1次，输出1个a
{m}
指定出现m次
import re
print(re.match('to{3}','toooooabatestasdtest')) #匹配t以及跟随在后面的三个ooo
print(re.match('to{3}','tooabatestasdtest')) #只有两个0,返回none{m,}
至少出现m次
import re
print(re.match('to{3,}','toooooabatestasdtest')) #匹配t以及跟随在后面的三个ooo至少出现3次
print(re.match('to{3,}','tooabatestasdtest')) #只有两个0,返回none
{m,n}
指定从m-n次的范围
import re
print(re.match('to{3,4}','toooabatestasdtest')) #刚好有三个ooo，成功匹配
print(re.match('to{3,4}','tooabatestasdtest')) #只有两个o,返回none
print(re.match('to{3,4}','toooooabatestasdtest')) #提取最多四个o四.匹配边界
如果上面匹配规则写的 .*直接匹配到所有的字符，但是我想只要其中一部分，所以这是需要设置一个边界，正则表达式中提供一些匹配边界的字符
| ^ | 匹配字符串开头 |
| $ | 匹配字符串结尾 |
| \b | 匹配一个单词的边界 |
| \B | 匹配非单词边界 |
$
匹配结尾字符，定义整个字符串必须以指定字符串结尾
import re
print(re.match('.*d$','2testaabcd')) #字符串必须以d结尾
print(re.match('.*c','2testaabcd')) #字符串不是以c结尾，返回none
^
匹配开头字符，定义整个字符串必须以指定字符开头
import re
print(re.match('^2','2stoooabatestas')) #规定必须以2开头，否则none
print(re.match('^2s','2stoooabatestas')) #必须以2s开头
\b
匹配一个单词的边界，表示字母数字与非字母数字的边界，非字母数字与字母数字的边界。即下面ve的右边不能有字母和数字
import re
print(re.match(r'.*ve\b','ve.2testaabcd')) #因为在python中\代表转义，所以前面加上r消除转义
print(re.match(r'.*ve\b','ve2testaabcd'))
\B
匹配非单词边界
import re
print(re.match(r'.*ve\B','2testaavebcdve')) #ve的右边需要有字母或者数字
print(re.match(r'.*ve\B','2testaave3bcdve'))五.匹配分组
| | | 匹配左右任意一个表达式 |
| （ab） | 将括号中字符作为一个分组 |
| \num | 引用分组num匹配到的字符串 |
| （?P<name>） | 分组起别名 |
| （?P=name） | 引用别名为name分组匹配到的字符串 |
|
匹配左右任意一个表达式，只要|两边任意一个表达式符合要求就行
import re
print(re.match(r'\d[1-9]|\D[a-z]','2233')) #匹配|两边任意一个表达式
print(re.match(r'\d[1-9]|\D[a-z]','as'))
(ab)
将括号中字符作为一个分组
()中的内容会作为一个元组字符装在元组中
import re
a = re.match(r'<h1>(.*)<h1>','<h1>你好啊<h1>')
print(a.group()) #输出匹配的字符
print(a.groups()) #会将()中的内容会作为一个元组字符装在元组中
print('`````````````')
b = re.match(r'<h1>(.*)(<h1>)','<h1>你好啊<h1>')
print(b.groups()) #有两括号就分为两个元组元素
print(b.group(0)) #group中默认是0
print(b.group(1)) #你好啊
print(b.group(2)) #h1六.sub函数和split函数
这两个函数是替换函数和分割函数。上代码吧，感觉和字符串函数类似
sub
查找字符串中所有相匹配到数据进行替换
sub(要替换的数据，替换成什么，要替换的数据所在的数据)
import re
print(re.sub('php','python','php是世界上最好的语言——php'))
#输出 "python是世界上最好的语言——python"
split
对字符串进行切割，并返回一个列表
import re
s = "itcase,java:php-php3;html"
print(re.split(r",",s)) #以,号进行分割
print(re.split(r",|:|-|;",s)) #以,或者：或者-或者;进行分割
print(re.split(r",|:|-|%",s)) #找不到的分隔符就忽略
# [itcase,java:php-php3;html] len=2
# [itcase,java,php,php3,html] len=5
# [itcase,java,php,php3;html] len=4七.贪婪和非贪婪
python里的数量词默认是贪婪的，总是尝试尽可能的匹配更多的字符。python中使用?号关闭贪婪模式
如
import re
print(re.match(r"aa\d+","aa2323")) #会尽可能多的去匹配\d
print(re.match(r"aa\d+?","aa2323")) #尽可能少的去匹配\dimport re
s = "this is a number 234-235-22-423"
# 1.贪婪模式
resule = re.match(r"(.+)(\d+-\d+-\d+-\d)",s) #我们本想数字和字母拆解成两个分组
print(resule.groups()) #('this is a number 23', '4-235-22-4')但我们发现输出的结果中23的数字竟然被弄到前面去了
#因为+它会尽可能多的进行匹配，\d，只需要一个4就能满足，所以前面就尽可能多的匹配
# 2.关闭贪婪模式
#在数量词后面加上 ?，进入非贪婪模式，尽可能少的进行匹配
result = re.match(r"(.+?)(\d+-\d+-\d+-\d)",s)
print(result.groups()) #('this is a number ', '234-235-22-4')
原文链接：https://blog.csdn.net/qq_44159028/article/details/120575621
结语
现在是北京时间00：06，实在太困了，睡觉，这篇文章大部分都是看上面的一篇文章，只是有一部分加入我自己的语言让我自己好了解一点，尊重原作者，明天练习正则表达式，今天是python小白，梦想是月入过万，mai起！
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
