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

2. . 匹配任意字符
   在正则表达式中，. 出现的位置可以匹配一个任意字符（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'>

3. \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'>

4. \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'>

5. \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小白'>

6. \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'>

7. ^ 检测字符串开头
   在math和fullmatch中没有意义，在search、findall等中有意义。

# 匹配一个字符串前3个是The，后面俩个是任意字符
re_str = r'^The..'
result = re.fullmatch(re_str, 'The')
print(result)

8. $ 检测字符串结尾
   在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'>

9. \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'>

10. [字符集] 匹配中括号中出现的任意一个字符

1. [普通字符集] 匹配中括号中出现的任意一个字符
   [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'>

11. [^字符集] 匹配不在字符集中的任何一个字符，^ 要放在字符集前

[^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

1. * 匹配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'))

2. + 至少匹配1次

a+ - a至少匹配一次
\d+ - 数字至少1次

print(re.fullmatch(r'a+b', 'aaab'))
# <_sre.SRE_Match object; span=(0, 4), match='aaab'>

3. ? 出现0次或1次

a? - a出现0次或1次，''和'a'可以匹配

# 写一个正则匹配一个整数（正负整数都行）， 123 10 +100 -100
re_str = r'[+-]?[1-9]\d*'
print(re.fullmatch(re_str, '-100'))

4. {}

{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']

4. 转义字符
   在正则表达式中可以在有特殊意义或者特殊功能的符号前加\来取消其特殊功能

\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)