一、正则表达式
1、正则表达式前戏
引言：
正则表达式式一门独立的技术，所有的编程语言都可以使用
它是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配，可用用来筛选和查找字符串中符合条件的数据。
2、字符组
须知：在中括号内填入相应字符，用来匹配与字符相应的数字或字母，字符组内所有的数据默认都是或的关系
用法表示：
[a值-b值] # 匹配a值到b值任意一个数
具体用法：
[0-9] # 匹配0-9之间任意一个数
[a-z] # 匹配a-z之间任意一个数
[A-z] # 匹配A-Z之间任意一个数
组合用法：
[0-9a-zA-Z] # 匹配数字或者小写字母或者大写字母
3、特殊符号
须知：特殊符号默认匹配方式是挨个匹配，顺序由左至右
| 序号 | 符号 | 含义/用法 |
|---|---|---|
| 1 | . | 匹配换行符以外的任意字符 |
| 2 | \w | 匹配字母、数字、下划线 |
| 3 | \W | 匹配非数字、非字母、非下划线 |
| 4 | \d | 匹配数字 |
| 5 | ^ | 匹配字符串的开头 |
| 6 | $ | 匹配字符串的结尾 |
| 7 | ^$ | 两则中间填入字符可用来精确匹配 |
| 8 | a|b | 匹配a或b（管道符是‘或’的意思） |
| 9 | () | 给正则表达式分组，不影响表达式匹配功能 |
| 10 | [] | 字符组内填写的内容默认都是或的关系 |
| 11 | [^] | 取反 匹配除了字符组内字符以外所有字符 |
4、量词
须知:
1.正则表达式默认情况下都是贪婪匹配>>>:尽可能多的匹配
2.两次必须结合表达式一起使用，不能单独出现，并且只影响左边第一个表达式：
kangkang{2}\d{5}
含义：'kangkang' 2次，\d 5次
| 序号 | 符号 | 含义/用法 |
|---|---|---|
| 1 | * | 默认是多次默 认是多次（无穷次） |
| 2 | + | 匹配一次或多次 默认是多次（无穷次） |
| 3 | ？ | 匹配0次或1次 默认是1次 |
| 4 | 重复n次 | |
| 5 | 重复n次或更多次 默认是更多次 | |
| 6 | 重复n-m次 默认是m次 |
5、贪婪匹配与非贪婪匹配
须知：所有量词默认都是贪婪匹配，想要变成非贪婪匹配就需要在量词后面加上‘问号’
- .# 属于典型的贪婪匹配，使用它，结束条件一般需要在左右添加条件
待匹配的文本：
<script>alert(123)</script>
贪婪匹配：
<.*> # <script>alert(123)</script>
非贪婪匹配：
<.*?> # <script>
6、转义符
须知：
1.斜杠与字母组合的时候有特殊含义
2.如果在python中可以使用r''取消转义
| 序号 | 符号 | 含义/用法 |
|---|---|---|
| 1 | \n | 匹配换行符 |
| 2 | \\n | 匹配文本\n |
| 3 | \\\n | 匹配文本\\n |
7、正则表达式实战
须知:
1.一般情况我们只需要能够写出简单的正则即可，达到能够读懂复杂的正则
2.很多时候，很多问题，已经有人做好了，并且上传到网络共享库，我们只需要花点时间寻找即可
常用的校验表达式:
1.Email地址：
^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$
2.手机号码：
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
3.电话号码：
\d{3}-\d{8}|\d{4}-\d{7}
4.身份证号(15位、18位数字)：
^\d{15}|\d{18}$
5.日期格式：
^\d{4}-\d{1,2}-\d{1,2}
6.腾讯QQ号：
[1-9][0-9]{4,}
7.中国邮政编码：
[1-9]\d{5}(?!\d)
二、re模块
引言：
re模块是python专门为正则提供的一种模块，其内置方法都是与正则方法相关
1、模块导入
代码表现：
imoprt re
2、常见操作方法
1.findall(pattern,string)
作用：
- 在字符串中找到正则表达式所匹配的所有子串, 并返回一个列表, 如果没有找到匹配的, 则返回空列表
- 返回所有满足匹配的结果, 按照顺序依次放入列表中, 如果没有匹配结果, 返回一个空列表
代码用法：
导入模块：
import re
代码用法：
print(re.findall("\w","ab* 12$ _"))
print(re.findall("\W","ab* 12$ _"))
-----------------------------------------------------------
# ['a', 'b', '1', '2', '_']
# ['*', ' ', '$', ' ']
2.finditer(pattern,string)
作用：
- 在字符串中找到正则表达式所匹配的所有子串, 并把它们作为一个迭代器返回
- 取值时需要使用‘双下next’，用法与迭代器一致
代码用法：
导入模块：
import re
代码用法：
res = re.finditer("\w", "ab* 12$ _")
print(res)
print(next(res))
print(next(res))
print(next(res))
print(next(res))
print(next(res))
-------------------------------------------------
<callable_iterator object at 0x0000025C885271F0>
<re.Match object; span=(0, 1), match='a'>
<re.Match object; span=(1, 2), match='b'>
<re.Match object; span=(4, 5), match='1'>
<re.Match object; span=(5, 6), match='2'>
<re.Match object; span=(8, 9), match='_'>
3.search(pattern,string)
作用：
- 扫描整个字符串并返回第一个成功的匹配
- 该对象可以通过调用 group() 方法得到匹配的字符串,如果字符串没有匹配，则返回None
- 如果没有匹配到值就调用 group() 方法, 抛出异常
代码用法：
导入模块：
import
代码用法：
print(re.search("abc","112abc333abc"))
print(re.search("abc","112abc333abc").group())
print(re.search("abcd","12abc333abc"))
print(re.search("abcd","12abc333abc").group())
-----------------------------------------------------------
# <re.Match object; span=(3, 6), match='abc'>
# abc
# None
# 报错 "AttributeError" (因为没拿到这个对象,所以没有group()属性
4.match(pattern,string)
作用：
-
与 re.search 功能相同, 但必须匹配起始位置, 不然返回 None
-
可以使用上尖号 ^ : re.search("^abc",“abc”) 实现 re.match() 功能
代码用法：
导入模块：
import re
代码用法：
print(re.match("abc","abc22abc")
print(re.match("abc","abc22abc").group())
print(re.match("abc","1abc22abc"))
print(re.search("^abc","1abcabc"))
---------------------------------------------------------
# <re.Match object; span=(0, 3), match='abc'>
# abc
# None
# None (re.search)
5.re.compile()
作用：
- 在该函数中传入“规则字符”, 返回一个对象, 它单独使用没有任何意义, 需要和 findall( ), search( ), match( ) 组合使用
代码用法：
代码导入：
import re
代码用法：
obj = re.compile("\d{2}")
print(obj)
print(obj.findall("ab12c33b44"))
print(obj.search("ab12c33b44").group())
print(obj.match("12c33b44").group())
-------------------------------------------------
# re.compile('\\d{2}')
# ['12', '33', '44']
# 12
# 12 (注意,必须在开头就匹配到,不然group会报错)
6.split()
作用：
- 将一个字符串按照正则表达式匹配结果进行分割, 返回列表类型
- 以规定字符作为分隔符对字符串进行切分, 切分结果放入列表, 没匹配到返回原字符串列表
-
将规定字符放入
[ ]则是逐个匹配
代码用法：
导入模块：
import re
代码用法：
print(re.split("o","abcoabcoabc"))
print(re.split("ab","abcoabcoabc"))
print(re.split("d","abcoabcoabc"))
print(re.split("[o]","abcoabcoabc"))
print(re.split("[ob]","abcoabcoabc"))
print(re.split("[oba]","abcoabcoabc"))
------------------------------------------------------
# ['abc', 'abc', 'abc']
# ['', 'co', 'co', 'c']
# ['abcoabcoabc'] (没匹配到返回原字符串)
# ['abc', 'abc', 'abc']
# ['a', 'c', 'a', 'c', 'a', 'c']
# ['', '', 'c', '', '', 'c', '', '', 'c']
# 先使用"o"匹配进行分隔, 得到结果"['abc', 'abc', 'abc']", 在使用"b"进行匹配分隔,得到结果后再使用"a"匹配进行分隔
7.sub() 和 subn()
作用：
- 匹配“规则字符”, 并将其该成指定字符, 返回改变后的字符串, 后面可跟个数参数, 不指定默认替换所有
- re.subn( ) 返回一个元组, 第二个元素返回的是替换的个数
代码用法：
导入模块：
import re
代码用法：
print(re.sub("a","A","i am a man"))
print(re.sub("a","b","i am a man"))
print(re.sub("am","b","i am a man"))
print(re.sub("a","AA","i am a man"))
print(re.sub("a","A","i am a man",1))
print(re.sub("a","A","i am a man",2))
print(re.sub("a","A","i am a man",3))
print(re.sub("a","A","i am a man",9))
print(re.subn("a","A","i am a man"))
print(re.subn("a","A","i am a man",2))
------------------------------------------------------------
# i Am A mAn
# i bm b mbn
# i b a man
# i AAm AA mAAn
# i Am a man
# i Am A man
# i Am A mAn
# i Am A mAn (超出字符串中最大的个数不会报错,而是替换所有)
# ('i Am A mAn', 3) (显示替换的个数)
# ('i Am A man', 2)
3、re模块补充说明
1.分组优先
res = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(res) # ['oldboy']
findall分组优先展示:优先展示括号内正则表达式匹配到的内容
res = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(res) # ['www.oldboy.com']
res = re.search('www.(baidu|oldboy).com', 'www.oldboy.com')
print(res.group()) # www.oldboy.com
res = re.match('www.(baidu|oldboy).com', 'www.oldboy.com')
print(res.group()) # www.oldboy.com
2.分组别名
res = re.search('www.(?P<content>baidu|oldboy)(?P<hei>.com)', 'www.oldboy.com')
print(res.group()) # www.oldboy.com
print(res.group('content')) # oldboy
print(res.group(0)) # www.oldboy.com
print(res.group(1)) # oldboy
print(res.group(2)) # .com
print(res.group('hei')) # .com
