17.1 正则基本符号
- 1.什么是正则表达式
正则表达式就是字符匹配的工具，用来做正则匹配；是由正则符号和普通字符组成，来匹配不同规律的字符串。
- 2.python对正则表达式的支持
python中提供了一个re模块，用来支持正则表达式。
fullmatch(正则表达式，字符串) - 用正则表达式去完全匹配字符串，如果匹配成功返回一个结果，失败返回None。
python中的正则表达式的写法：将正则内容写在字符串中，一般这个字符串的最前面会加r或R用来阻止转义。
import re
str1 = 'dhsuwqy82r21r372cuefy12fgy1983r1y283781382g1f382321382r3g21'
str2 = '18408266183'
str3 = 'zh@qq.com'
1.普通字符
普通字符在正则表达式中，代表字符本身。
# 匹配一个字符串，第一个字符是a，第二个字符是b，第三个字符也是最后一个字符是c。
re_str = r'abc'
result = re.fullmatch(re_str, 'abc')
print(result) # <_sre.SRE_Match object; span=(0, 3), match='abc'>
result1 = re.fullmatch(re_str, 'abcd')
print(result1) # None
- . 匹配任意字符
在正则表达式中，. 出现的位置可以匹配一个任意字符（char）
注意：一个.只能匹配一个字符
# 匹配一个长度为3的字符串。且第一个字符是a，最后一个字符是c，中间一个字符是任意一个字符。
re_str = r'a.c'
result = re.fullmatch(re_str, 'a$c')
print(result) # <_sre.SRE_Match object; span=(0, 3), match='a%c'>
- \w 匹配字母数字或下划线的符号
在正则表达式中，\w出现的位置，可以匹配一个任意的字母数字或下划线的符号（其实也可以匹配Unicode编码中除了Ascii码剩下的部分。）
中文也能匹配
# 匹配一个长度是5的字符串，并且字符串前两位是任意的字母数字或下划线符号,后3位是任意字符
re_str = r'\w\w...'
result = re.fullmatch(re_str, '小白a$c')
print(result) # <_sre.SRE_Match object; span=(0, 5), match='小白a$c'>
- \s 匹配一个空白字符
空白字符：包括空格、制表符、换行符（空格，\t,\r,\n）
# 匹配一个长度是4的字符串，并且前两位是字母数字下划线或中文，中间一个空白符，最后
# 以一个字母数字下划线或中文结尾。
re_str = r'\w\w\s\w'
result = re.fullmatch(re_str, '小白\ne')
print(result) # <_sre.SRE_Match object; span=(0, 4), match='小白\ne'>
- \d 匹配数字字符
# 匹配一个长度是5的字符串，字符串的前三位是数字字符，后两位是任意字符
re_str = r'\d\d\d..'
result = re.fullmatch(re_str, '123小白')
print(result) # <_sre.SRE_Match object; span=(0, 5), match='123小白'>
- \b 检测单词边界
注意：\b位置不会被用于匹配，只是检测该位置是否是单词边界，不会对字符进行匹配，不会记入字符串长度。当正则表达式中出现了\b，匹配时去掉\b匹配成功后再看\b出现的位置是否是单词边界。
单词边界：字符串开头、字符串结尾、标点符号、空白符号等只要能将单词区分开的符号都属于单词边界。
匹配前先把\b去掉，再去匹配，匹配时再找满足条件的。
# 下句既要求helloworld又要求两单词分开
re_str = r'hello\bworld' # 没有任何一个字符串能和它匹配
re_str1 = r'\bhello,\bworld' # 没有任何一个字符串能和它匹配
result = re.fullmatch(re_str1, 'hello,world')
print(result) # <_sre.SRE_Match object; span=(0, 11), match='hello,world'>
- ^ 检测字符串开头
在math和fullmatch中没有意义，在search、findall等中有意义。
# 匹配一个字符串前3个是The，后面俩个是任意字符
re_str = r'^The..'
result = re.fullmatch(re_str, 'The')
print(result)
- $ 检测字符串结尾
在math和fullmatch中没有意义，在search、findall等中有意义。
# 匹配一个字符串只要3位，分别是The，并且e后结尾。所以在这无意义
re_str = r'^The$'
result = re.fullmatch(re_str, 'The')
print(result) # <_sre.SRE_Match object; span=(0, 3), match='The'>
- \W 匹配一个非字母数字下划线中文的字符
\大写字母 对应的功能是 \小写字母 功能取反
\W 匹配一个非字母数字下划线中文的字符
\D 匹配一个非数字字符
\S 匹配一个非空白字符
\B 检测非单词边界
# 匹配一个字符串，第一个是数字，第二个非数字，第三个是空白，第四个是数字字母下划线，最后
# 一个是a，并且要求最后一个a前不是单词边界。
re_str = r'\d\D\s\w\Ba'
result = re.fullmatch(re_str, '9H\tAa')
print(result) # <_sre.SRE_Match object; span=(0, 5), match='9H\tAa'>
- [字符集] 匹配中括号中出现的任意一个字符
- [普通字符集] 匹配中括号中出现的任意一个字符
[abc] - 匹配一个字符是a或b或c
注意：
a.一个中括号只能匹配一个字符
b.正则中有特殊功能的单个符号例如：. $ ^ + * ? | 等。
c.匹配字符的组合符号在中括号中保持原来的功能：如\w \d \s \W \D \S
# 匹配一个长度是2的字符串，第一个字符是数字，第二个字符是b或c或d
re_str = r'\d[bcd\d]'
result = re.fullmatch(re_str, '22')
print(result) # <_sre.SRE_Match object; span=(0, 2), match='22'>
2.[字符1-字符2] - 表示字符1到字符2（注意：要求字符1的编码值要小于字符2）
[a-z] - 表示匹配所有的小写字母
[A-Z] - 表示匹配所有的大写字母
[a-zA-Z] - 表示匹配所有的字母
[1-7] - 表示数字字符1到7
[\u4e00-\u9fa5] - 匹配所有的中文
[字符1字符2-] - 这儿的-表示减号本身
# 匹配一个长度是3的字符串，第一个字符是数字字符1到7的一个，第二个字符是a、b、c、-
# 中的一个，第三个是小写字母
re_str = r'[1-7][abc-][a-z]'
result = re.fullmatch(re_str, '3-z')
print(result) # <_sre.SRE_Match object; span=(0, 3), match='3-z'>
- [^字符集] 匹配不在字符集中的任何一个字符，^ 要放在字符集前
[^abc] - 匹配除了abc以外的任意一个字符
[^\d] - 匹配除了数字字符以外的任意一个字符
[^a-z] - 匹配除了小写字母以外的任意一个字符
[abc^d] - 匹配abcd或^中的任意一个字符。
re_str = r'[^abc]'
result = re.fullmatch(re_str, '3')
print(result) # <_sre.SRE_Match object; span=(0, 1), match='3'>
17.2 正则控制匹配次数
import re
- * 匹配0次或多次
a* - a连续出现0次或多次；'','a','aaa', ' '
\d* - 任意数字连续出现0次或多次。'','1','12','245432542354'都可以匹配
[abc]* - a或b或c连续出现0次或多次。
[A-F]* - A到F中任意字符出现0次或多次。
注意：在[]外面的*的前面需要一个字符或者一个匹配字符的符号
# <_sre.SRE_Match object; span=(0, 10), match='aaaaaaaaab'>
print(re.fullmatch(r'a*b', 'aaaaaaaaab'))
- + 至少匹配1次
a+ - a至少匹配一次
\d+ - 数字至少1次
print(re.fullmatch(r'a+b', 'aaab'))
# <_sre.SRE_Match object; span=(0, 4), match='aaab'>
- ? 出现0次或1次
a? - a出现0次或1次，''和'a'可以匹配
# 写一个正则匹配一个整数（正负整数都行）， 123 10 +100 -100
re_str = r'[+-]?[1-9]\d*'
print(re.fullmatch(re_str, '-100'))
- {}
{N} - 匹配N次，如a{3} - 匹配3个’a‘
{M，N} - 匹配M到N次，如a{3，5} - 'aaa' 'aaaa' 'aaaaa'
{,N} - 最多匹配N次，即0到N次。如a{,3} - '','a','aa','aaa'
{M,} - 至少匹配M次，如a{3,} - 'aaa','aaaa'...
print(re.fullmatch(r'a{,3}', ' '))
# 密码由字母数字组成数字不开头，6-12位，给出提示
password = input('密码：')
re_str = r'[a-zA-Z]{1}[a-zA-Z0-9]{5, 11}'
re_str = r'[a-zA-Z][a-zA-Z0-9]{5, 11}'
if not re.fullmatch(re_str, password):
print('错误。')
17.3 分支、捕获和贪婪
import re
1.分支
条件1 | 条件2 - 匹配条件1或者条件2
\d{2} | [a-z] - 匹配俩个数字字符，或者一个小写字母
a\d{2}|\w{2} - 匹配1个a后面2个数字，或者两个数字字母下划线。
注意：正则中分支也会短路，当条件1可以匹配，就不会再使用条件2匹配
# <_sre.SRE_Match object; span=(0, 2), match='33'>
print(re.fullmatch(r'\d{2}|[a-z]', '33'))
# <_sre.SRE_Match object; span=(0, 1), match='a'>
print(re.fullmatch(r'\d{2}|[a-z]', 'a'))
# <_sre.SRE_Match object; span=(0, 3), match='a33'>
print(re.fullmatch(r'a\d{2}|\w{2}', 'a33'))
# <_sre.SRE_Match object; span=(0, 2), match='a3'>
print(re.fullmatch(r'a\d{2}|\w{2}', 'a3'))
# 匹配所有的数字 100 -100 12.5 -12.5 0 0.012
"""
12,12.34
0.123
0
"""
re_str = r'[+-]?[1-9][0-9]*|[+-]?[0-9]*[.][0-9]*|0'
# re_str = r'[+-]?[1-9][0-9]*[.]?\d*|[+-]?0[.]?[0-9]+|0' 老师
print(re.fullmatch(re_str, '-12.5'))
print(re.fullmatch(re_str, '-0.5989'))
print(re.fullmatch(re_str, '0123'))
print(re.fullmatch(re_str, '123'))
print(re.fullmatch(re_str, '+123'))
print(re.fullmatch(re_str, '0.012'))
print(re.fullmatch(re_str, '+0.012'))
print(re.fullmatch(re_str, '-0.012'))
print(re.fullmatch(re_str, '0'))
print(re.fullmatch(re_str, '-0.3'))
2.捕获和分组
a.分组 - 将括号中的内容作为一个整体
r'abc\d{3}|abc[A-Z]{3}' = r'abc(\d{3}|[A-Z]{3})'
# 匹配一个字符串，前3位是abc，后3位是数字或者大写字母
# r'abc\d{3}|abc[A-Z]{3}' = r'abc(\d{3}|[A-Z]{3})'
# 匹配一个字符串，以‘数字小写字母’的形式出现3次
re_str = r'(\d[a-z]){3}'
# <_sre.SRE_Match object; span=(0, 6), match='1a2s3d'>
print(re.fullmatch(re_str, '1a2s3d'))
b.捕获
通过正则获取符合条件的子串时，可以在正则表达式中加括号，匹配后只获取括号里面匹配到的内容。例1：
re.findall(正则表达式，字符串) - 在字符串中去获取符合正则表达式条件的所有子串，返回一个列表。
str1 = '32e23i1hr32hru392r3hu21re3u21hre32h1iufe3h2r'
# ['32', '23', '1', '32', '392', '3', '21', '3', '21', '32', '1', '3', '2']
print(re.findall(r'\d+', str1))
# 例1：
# ['e23', 'e3', 'e32', 'e3']
print(re.findall(r'e\d+', str1))
# ['23', '3', '32', '3']
print(re.findall(r'e(\d+)', str1))
c.重复匹配
写一个带多个分组的正则表达式，可以在分组后面通过添加 \数字 来重复前面第几个分组中匹配到的内容。
说明：\数字 - 这里的数字代表前面第几个分组；\1代表第一个分组，\2代表第2个组
re_str = r'\d{3}([a-z]{2})a\1'
# <_sre.SRE_Match object; span=(0, 8), match='222sdasd'>
print(re.fullmatch(re_str, '222sdasd'))
re_str = r'(\d{3})([a-z]{2})a\1\2'
print(re.fullmatch(re_str, '222sda222sd'))
3.贪婪
匹配次数后加？就是贪婪匹配：*? +? ?? {M,N}? {M,}? 表示尽可能少的重复
re_str = r'a.+b'
str1 = 'xxxahdjbnnkbsssammmb'
print(re.findall(re_str, str1)) # ['ahdjbnnkbsssammmb']
re_str = r'a.+?b'
print(re.findall(re_str, str1)) # ['ahdjb', 'ammmb']
- 转义字符
在正则表达式中可以在有特殊意义或者特殊功能的符号前加\来取消其特殊功能
\w - 代表两个字符分别为反斜杠和w
+ - 代表加号字符
* - 代表*
? - 代表?
() - 表示（），类推[]及{}
注意：
在中括号中，\必须加\表示反斜杠本身。
^在最前面时，必须加\表示^本身
-在两个字符之间并在中括号里面时，必须加\表示-本身
re_str = r'\w-\d{3}'
17.4 re模块
import re
1.compile
compile(正则表达式) - 将正则表达式转换成正则表达式对象
re_str = r'\d{3}'
re_obj = re.compile(re_str)
# 调用模块中函数
print(re.fullmatch(re_str, '338'))
# 调用对象方法
print(re_obj.fullmatch('338'))
2.match和fullmatch
a.fullmattch(正则表达式，字符串) - 完全匹配，从字符串开头一直到结尾
b.mattch(正则表达式，字符串) - 不完全匹配，只匹配字符串开头。
re_str = r'\d[A-Z]{2}'
# 完全匹配 <_sre.SRE_Match object; span=(0, 3), match='6AD'>
print(re.fullmatch(re_str, '6AD'))
# 不完全匹配 <_sre.SRE_Match object; span=(0, 3), match='6AD'>
print(re.match(re_str, '6AD2签位尔特3ytuytjytj'))
匹配对象
1.获取span - 匹配到内容在字符串中的范围（开始下标，结束下标），结束下标取不到
匹配对象.span() - 获取整个正则表达式匹配到的范围
匹配对象.span(n) - 获取正则表达式中第n个分组匹配到的范围，前提是有分组。
# (0, 3)
print(re.match(re_str, '6AD2签位尔特3ytuytjytj').span())
# (0, 1)
print(re.match(r'(\d)[A-Z]{2}', '6AD2签位尔特3ytuytjytj').span(1))
# (1,3)
print(re.match(r'(\d)([A-Z]{2})', '6AD2签位尔特3ytuytjytj').span(2))
2.start和end - 获取匹配结果的开始下标和结束下标。
匹配对象.start()/匹配对象.end() - 获取整个正则表达式匹配到的的开始下标和结束下标。
匹配对象.start(n)/匹配对象.end(n) - 获取整个正则表达式第n个分组，匹配到的的开始下标和结束下标。
3.group - 获取匹配到的内容
匹配对象.group() - 获取整个正则表达式匹配到的内容
匹配对象.group(n) - 获取正则表达式第n个分组匹配到的内容
4.string - 获取用来匹配的原字符串
匹配对象.string()
3.search
search(正则表达式，字符串) - 匹配字符串中第一个满足正则表达式的子串，如果匹配成功，返回匹配对象，否则返回None
str1 = r'abc123hkcajsa121df'
result = re.search(r'\d{3}[a-z]{2}', str1)
print(result) # <_sre.SRE_Match object; span=(3, 8), match='123hk'>
4.spilt
split(正则表达式，字符串) - 在字符串中按照满足正则表达式条件的子串对字符串进行切割。返回一个列表
str1 = 'ab+c7wewfwefewff79wfqe9fwq9qw0e*f'
# ['ab+c', 'wewfwefewff', 'wfqe', 'fwq', 'qw', 'e*f']
print(re.split(r'\d+', str1))
# ['ab', 'c', 'wewfwefewff', 'wfqe', 'fwq', 'qw', 'e', 'f']
print(re.split(r'\d+|[+*-]+', str1))
5.sub
sub(正则表达式，新子串，字符串) - 用新子串替换字符串中满足正则表达式的子串，返回一个替换后的字符串
str1 = 'i32h1e32jirh32iu1ej321eji'
print(re.sub(r'\d+', '$', str1)) # i$h$e$jirh$iu$ej$eji
6.findall
findall(正则表达式，字符串) - 在字符串中获取满足正则表达式的所有的字符，返回一个列表，列表元素就是字符串。
注意：如果此处正则表达式中有一个分组，结果是列表中只取括号中匹配到的字符串，如果分组大于1，结果是一个列表，列表元素是元组，元组中元素为每个括号中匹配到的字符串。（先匹配整个再取括号中内容！）
str1 = 'sdad434w2rsdvsvds34==='
print(re.findall(r'\d+', str1)) # ['434', '2', '34']
str1 = 'sdad434w2rsdvsvds34==='
print(re.findall(r'(\d+)(\w)', str1))
# [('434', 'w'), ('2', 'r'), ('3', '4')]
7.finditer
finditer(正则表达式，字符串) - 在字符串中获取满足正则表达式的内容，返回一个迭代器，迭代器元素是匹配对象。
str1 = 'sdad434w2rsdvsvds34==='
print(re.finditer(r'\d+', str1))
# 写一个自己的finditer
def my_finditer(pattern, string):
re1 = re.search(pattern, string)
while re1:
yield re1
string = string[re1.end():]
# 考虑对正则取反（think）
re1 = re.search(pattern, string)
