1.正则基本符号

1.1.什么是正则表达式
正则表达式就是字符匹配的工具；是由正则符号和普通字符组成，来匹配不同规律的字符串
1.2.python对正则表达式的支持
python中提供了一个re模块，用来支持正则表达式
fullmatch(正则表达式，字符串) - 用正则表达式去完全匹配字符串，如果匹配成功返回一个匹配结果,失败则返回None
python中的正则表达式的写法：将正则内容写在字符串中，一般这个字符串的最前面加r/R,
1.3.正则表达式中的普通字符
普通字符在正则表达式中，代表字符本身

import re
# 匹配一个字符串，第一个字符是a,第二个字符是s，第三个字符也是最后一个字符d
re_ste = r'asd'
result = re.fullmatch(re_ste, 'asd')
print(result)

1.4 .(点) - 匹配任意字符
在正则表达式中，点出现的位置可以匹配一个任意字符
注意：一个点只能匹配一个字符

# 匹配一个长度是3的字符串，并且第一个字符是'a',最后一个是'c',中间是任意字符
re_str = r'a.c'
result = re.fullmatch(re_str, 'a\\c')
print(result)

1.5.\w(匹配字符，数字或者下划线)
在正则表达式中，\w出现的位置，可以匹配一个任意的字母，数字或者下划线,其实也可以匹配Unicode编码中,除了ASCII码剩下的部分
注意：一个\w只能匹配一个字符，中文也能匹配

# 匹配一个长度是5的字符串，并且字符串的前两位是数字，字母，下划线，后面是三个任意字符
re_str = r'\w\w...'
result = re.fullmatch(re_str, '_好kll')
print(result)

1.6.\s(匹配空白字符)
空白字符包括：空格，制表符和换行符(空格，\t, \r, \n)

# 匹配一个长度是4的字符串，并且字符串前两位是字母，数字或者下划线（中文），中间一个空白，再一个字母
# 数字或者下划线
re_str = r'\w\w\s\w'
result = re.fullmatch(re_str, 'w3\rj')
print(result)

1.7.\d(匹配数字字符)

# 匹配一个长度是5的字符串，字符串的前三位是数字字符，后面两位是任意字符
re_str = '\d\d\d..'
result = re.fullmatch(re_str, '123d[')
print(result)

1.8.\b(检测单词边界)
注意：\b是检测\b出现的位置是否是单词边界，不会对字符进行匹配。当正则表达式中出现了\b，匹配的时候去掉\b，匹配成功后再看\b出现的位置是否是单词边界
单词边界：字符串开头，字符串结尾，标点符号，空白符号等(只要能够将单词区分开的符号都属于单词边界)

# 匹配字符串'hello,world',并且要求w前面是单词边界,h前面也是单词边界
re_str = r'\bhello,\bWor\vld'
result = re.fullmatch(re_str, 'hello,World')
print(result)

1.9.^(检测字符串开头)
在match和fullmatch中没有意义，search,findall等中有意义

# 匹配一个字符串前面三个字符是The,后面两个是任意字符
re_str = '^The..'
result = re.fullmatch(re_str, 'Thell')
print(result)

1.10.$(检测字符串结尾)
在match和fullmatch中没有意义，search,findall等中有意义

# 匹配一个字符串，只有三位，分别是The,并且e后面是字符串结尾
re_str = r'The$'
result = re.fullmatch(re_str, 'The')
print(result)

1.11.\大写字母
'\大写字母'对应的功能是'\小写字母'功能取反
\W(大写W) - 匹配非数字，字母，下划线
\D(大写D) - 匹配非数字字符
\S(大写S) - 匹配非空白字符
\B(大写B) - 匹配非单词边界

# 匹配第一个字符是数字，第二个是非数字,第三个是空白，第四个是数字，字母或下划线，
# 最后一个是a，a的前面不是单词边界
re_str = r'\d\D\s\w\Ba'
result = re.fullmatch(re_str, '4f\t_a')
print(result)

1.12.[字符集]（匹配中括号中出现的任意一个字符）
1.[字符集] - 匹配中括号中出现的任意一个字符
例如：[abc] - 匹配一个字符是a或者b或者c
注意：
1)一个中括号只能匹配一个字符
2)正则中有特殊功能的单个符号在[]都表示符号本身 例如：. $ ^ + * ? |等
3)匹配字符的组合符号，在中括号中保持原来的功能，例如：\w \s \d \D \S \W

# 匹配一个长度是2的字符串，第一个是数字，第二个是b或者c或者=
re_str = r'\d[bc=]'
result = re.fullmatch(re_str, '4=')
print(result) #<_sre.SRE_Match object; span=(0, 2), match='4='>

1.13.[字符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, '6-a')
print(result)

1.14.[^字符集] - 匹配不在字符集中的任何一个字符
[^abc] - 匹配除了a，b，c以外的任何一个字符
[^\d] - 匹配除了数字字符以外的任何一个字符
[^a-z] - 匹配除了小写字符以外的任何一个字符
[abc^] - 匹配a,b,c,^中的任何一个

2.正则控制匹配次数

2.1.(匹配0次或者多次)
a - a出现0次或者多次，'' 'a' 'aa' 'aaa'...都可以匹配
\d* - 任意数字出现0次或者多次， '' '1' '12' '1224' ...都可以匹配
[abc]* - a，b，c出现0次或者多次
[A-F]* - A到F中任意字符出现0次或者多次
注意：在[]外面的*的前面需要一个字符或者一个匹配字符的符号

import re
print(re.fullmatch(r'a*b', 'aaaaaab'))
print(re.fullmatch(r'\d*', '12353'))

2.2.+(匹配1次或者多次
a+ - a至少出现一次
\d+ - 数字至少出现一次

print(re.fullmatch(r'a+b+', 'aabbbb'))

2.3.?(匹配0次或者1次)
a? - a出现0次或者1次，'' 'a'可以匹配

# 写一个正则表达式匹配一个整数（正整数和负整数都可以），123,10，+100 -1234
re_str = r'[1-9+-]\d+'
re_str1 = r'[-+]?[1-9]\d*'
re_str = re.fullmatch(re_str, '9767')
print(re_str)

2.4.{}
{N} - 匹配N次，例如：a{3}:匹配三个a
{M,N} - 匹配M到N次 例如：a{3,5},匹配三个a,或者4个a,或者5个a
{,N} - 最多匹配N次（0-N）- 例如：a{,3},'','a','aa','aaa'
{M,} - 至少匹配M次 例如：a{3,},'aaa','aaaa'.......

# 练习：输入密码，要求检测密码输入是否合格（密码由字母和数字，数字不开头，6-12位，合格给出提示）
re_str = r'[a-zA-Z][\da-zA-Z]{5,11}'
result = re.fullmatch(re_str, 'a4345grtr')
if result:
    print('输入成功')
else:
    print\
        ('输入有误')

3.分之、捕获和贪婪

3.1.分之
条件1 | 条件2 - 匹配条件1或者条件2
\d|[a-z] - 匹配一个数字字符或者一个小写字母
a\d{2}|\w{2} - 匹配一个a加两个数字或者两个数字，字母，下划线
注意：正则中的分之也会出现短路，当条件1可以匹配，就不会再使用条件2进行匹配

import re
print(re.fullmatch(r'\d{2}|[a-z]', '23'))
print(re.fullmatch(r'a\d{2}|\w{2}', 'a23'))
# 练习:写一个正则表达式，匹配所有的数字 例如100，+100，-100,12.5 -12.5 +12.5,0
re_str = r'[+-]?[1-9]\d*[.]?\d*|[+-]?0\d+|0'
result = re.fullmatch(re_str, '-12.5')
print(result)

3.2.捕获和分组
a.分组 - 将括号中的内容作为一个整体

# 匹配一个字符串，前三位值abc,后三位时候三个数字或者是三个大写字母
re_str = r'abc(\d{3}|[A-Z]{3})'
print(re.fullmatch(re_str, 'abcDAF'))
# 匹配一个字符串，以’数字小写字母‘的形式出现多次
re_str = r'(\d[a-z]){3}'
print(re.fullmatch(re_str, '1a2a3s'))

b.捕获 - 在通过正则获取符合条件的子串的时候，可以在正则表达式中加括号，匹配后只获取括号里面匹配到的内容
re.findall(正则表达式，字符串) - 在字符串中取获取符合正则表达式条件的所有的子串，返回一个列表

str1 = 'oia2rojkga9f8f8f4rlkgjiew9f3f9'
print(re.findall(r'f(\d+)', str1))

c.重复匹配
带多个分组的正则表达式中可以在分组的后面通过添加'\数字'来重复前面第几个分组中匹配到的内容
说明：\数字 - 这儿的数字代表前面第几个分组；\1代表第一个分组，\2代表第二个分组
3.3.贪婪(用的多)
匹配次数后加?就是贪婪匹配：*? ,+?, ??, {M,N}?, {M,}?表示尽可能少的重复

re_str = r'a.+?b'
str1 = 'xxxahdjbnnkbsssammmb'
print(re.findall(re_str, str1))

3.4.转义符号
在正则表达式中可以在有特殊意义或者特殊功能的符号前加反斜杠来取消其特殊的功能
\w - 代表两个字符，分别是反斜杠\和w
+ - 代表+字符
? - 代表?字符
* - 代表*字符
(),{},[]表示字符的时候，前面也加
在中括号中，\必须加\表示反斜杠本身，^{在最前面的时候加\表示}本身，-在两个字符之间加\表示-本身

4.re模块

4.1.1.compile(了解)
compile(正则表达式) - 将正则表达式转换成正则表达式对象
转换成对象后可以通过对象调用对象方法

re_str = '\d{3}'
re_obj = re.compile(re_str)
re.fullmatch(re_str, '234')
print(re.fullmatch(re_str, '234'))
print(re_obj.fullmatch('234'))

4.2.match和fullmatch
a.fullmatch(正则表达式，字符串) - 完全匹配，从字符串开头匹配到字符串结束
b.match(正则表达式，字符串) - 不完全匹配，只匹配字符串开头
匹配成功返回匹配对象，匹配失败返回None

re_str = r'\d[A-Z]{2}'
result = re.fullmatch(re_str, '2FD')
print(result)
result1 = re.match(re_str, '2DSlkjkjiej==')
print(result1)

4.3.匹配对象
a.获取span - span是匹配到的内容的范围（开始下标，结束下标），结束下标取不到
匹配对象.span() - 获取整个正则表达式匹配到的范围
匹配对象.span(n) - 获取正则表达式中第n个分组匹配到的范围（前提是有分组）

print(result1.span())
# print(result1.span(1))

b.start和end - 获取匹配结果的开始下标和结束下标
匹配对象.start()/匹配对象.end() - 获取整个正则表达式匹配到的开始下标/结束下标
匹配对象.start(n)/匹配对象.end(n) - 获取正则表达式中第n个分组匹配到的开始/结束下标

print(result1.start())
print(result1.end())

c.group() - 直接获取匹配到的内容
匹配对象.group() - 获取整个正则表达式匹配到的内容
匹配对象.group(n) - 获取正则表达式中第n个分组匹配到的内容
d.string - 获取用来匹配的原字符串
匹配对象.string

print(result1.string)

4.4.search
search(正则表达式，字符串) - 匹配字符串中第一个满足正则表达式的子串,
如果匹配成功返回匹配对象，否则返回None

str1 = 'abc123hks362shjjk990kll'
result = re.search(r'\d{3}[a-z]{2}', str1)
print(result)

4.5.split
split(正则表达式，字符串) - 在字符串中按照满足正则表达式条件的子串对字符串进行切割,返回一个列表

str1 = 'ab+abc7hdjd8jss-sk9sjjs9kk*k'
print(re.split(r'\d+|[+*-]+', str1))

4.6.sub
sub(正则表达式，新子串，字符串) - 用新子串替换字符串中满足正则表达式的子串，返回一个替换后的字符串
4.7.findall
findall(正则表达式，字符串) - 在字符串中获取满足正则表达式的所有的子串，返回一个列表，列表元素是字符串
注意：如果正则表达式中有一个分组，结果就是列表中只取分组匹配到的字符串,如果这个正则表达式中分组的个数大于1，结果是一个列表，列表中的元素是元组，元组中是每个分组匹配到的内容

str = 'haja37jjkd89sdhs909nnna230==='
result = re.findall(r'[a-zA-Z](\d+)([a-z+?])', str)
print(result)

4.8.finditer
finditer(正则表达式，字符串) - 获取字符串中满足正则表达式的内容，返回的是一个迭代器，迭代器找那个的元素是匹配对象

result = re.finditer(r'[a-zA-Z](\d+)([a-z+?])', str)
print(result)
print(next(result))