1.正则基本符号

1.什么是正则表达式
正则表达式就是字符匹配工具；是由正则符号和普通字符组成，来匹配不同规律的字符串

2.python对正则表达式的支持
python中提供了一个re模块，用来支持正则表达式
fullmatch(正则表达式，字符串) -
用正则表达式去完全匹配字符串，如果匹配成功.返回一个匹配结果，失败返回None
python中的正则表达式的写法：将正则内容写在字符串中，一般这个字符串最前面会加一个r/R

"""
import re

1.普通字符

"""
普通字符在正则表达式中代表字符本身
"""

匹配一个字符串，第一个字符是a,第二个字符是b,第三个字符也是最后一个字符是'c'

re_str = r'abc'
result = re.fullmatch(re_str, 'abc')
print(result)

2. .(匹配除‘\n’外的任意字符)

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

匹配一个长度是3的字符串，并且第一个字符是'a',最后一个字符是'c',中间是任意字符

re_str = r'a.c'
result = re.fullmatch(re_str, 'a\tc') # \n不能匹配
print(result)

3. \w(匹配字母数字或者下划线)

"""
在正则表达式中，\w出现的位置，可以匹配 一个 任意的字母、数字或者下划线(也可以匹配Unicode编码中除了ASCLL码剩下的部分)
"""

匹配一个长度是4的字符串，并且字符串的前一位是数字字母或者下划线，后面三位是任意字符

re_str = r'\w...'
result = re.fullmatch(re_str, '22kk')
print(result)

4.\s(匹配空白字符)

"""
空白字符包括:空格、制表符和换行符
"""

匹配一个长度是4的字符串，并且字符串前两位是数字字母或者下划线(中文)，中间空白，再一个数字字母下划线（中文）

re_str = r'\w\w\s\w'
result = re.fullmatch(re_str, 'h2\n8')
print(result)

5.\d(匹配数字字符)0-9

re_str = r'\d\d..'
result = re.fullmatch(re_str, '12.\')
print(result)

6.\b(检测单词边界)

"""
注意：检测 \b 出现的位置是否是单词边界，不会对字典进行匹配。

单词边界：单词开头，单词结尾，标点符号，空白符号等，只要能够将单词区分开的符号都属于单词边界
"""
re_str = r'hello\b python'
result = re.fullmatch(re_str, 'hello python')
print(result)

7.^(检测字符串开头)

"""
在match和fullmatch中没有意义，在search,findall等中有意义
"""

匹配一个字符串前面三个字符是否是'The',后面三个是任意字符

re_str = r'^The...'
result = re.fullmatch(re_str, 'The123')
print(result)

8.$(检测字符串结尾)

"""
在match和fullmatch中没有意义，在search,findall等中有意义
"""

匹配一个字符串，只有三位，分别是'The'

re_str = r'The$'
result = re.fullmatch(re_str, 'The')
print(result)

9.

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

10.

"""

例如：[字符集] - 匹配字符集中的任意一个字符

注意：a.一个中括号只能匹配一个字符
b.正则表达式的单个符号都代表本身例如： . $ ^ + * ? | 等
c.匹配字符的组合符号，在中括号中保持原来的功能，例如：\w, \d, \S等
"""
re_str = r'\d[abc]'
result = re.fullmatch(re_str, '1c')
print(result)

"""
2.[字符1-字符2] - 表示字符1到字符2（注意：字符1的编码值要小于字符2）
[a-z] - 表示所有的小写字母
[A-Z] - 表示所有的大写字母
[a-zA-Z] - 表示所有的字母
[0-9] - 表示数字0到9
[\u4e00-\u9fa5] - 匹配所有的中文
[字符1字符2-] - 这儿的 - 表示减号本身
"""
re_str = r'[0-9]'
result = re.fullmatch(re_str, '0')
print(result)

11.[^字符集] - 匹配不在字符集中的任意一个字符

"""
[^abc] - 匹配除了'a','b','c'以外的任意一个字符
[^a-z] - 匹配除了小写字母以外的任意一个字符
[abc^] - 匹配'a','b','c','^'中的任意一个字符
"""

2.正则控制次数

import re

1.*（匹配0次或者多次）

"""
a* - a 出现0次或者多次， '','a', 'aaa'...
\d* - 任意数字出现0次或者多次
[abc]* - 字符a,b,c出现0次或者多次
"""
print(re.fullmatch(r'a*b', 'aaaab'))

2. +（匹配至少一次或者多次）

3. ?(匹配0次或者1次)

写一个正则表达式匹配一个整数（正整数和负整数都可以）

re_str = r'[+-][1-9][0-9]'
result = re.fullmatch(re_str, '0')
print(result)

4.{}

"""
{N} - 匹配N次,a{3} 匹配三个'a'
{M,N} - 匹配M到N次,M比N小
{,N} - 最多匹配N次
{M,} - 至少M次
"""

练习：输入密码，要求检查密码输入是否合格（密码由字母数字组成，数字不开头，6-12位）。给出提示是否正确

re_str = r'[a-zA-Z][\da-zA-Z]{5,11}'
mima = input('请输入密码：')
if re.fullmatch(re_str, mima):
print('密码输入正确！')
else:
print('密码输入错误！')

3.分支、捕获和贪婪

1.分支

"""
条件1|条件2 - 匹配条件1或者条件2
注意：正则表达式中分支也会出现短路，当条件1可以匹配，就不会使用条件2进行匹配
"""

练习：写一个正则表达式，匹配所有的数字

import re

print(re.fullmatch(r'[+-]?0[.]?\d|[+-]?[1-9]+[.]\d*', '-1.0'))

2.()捕获和分组

"""
a.分组 - 将括号的内容作为一个整体
"""
re_str = r'abc(\d{3}|[A-Z]{3})'
print(re.fullmatch(re_str, 'abc123'))
re_str = r'(\d[a-z]){3}'
print(re.fullmatch(re_str, '2d3d5f'))

"""
b.捕获
通过正则获取符合条件的子串的时候，可以再正则表达式中加括号，来实现匹配后只返回以括号中匹配到的内容为元素的列表
re.findall(正则表达式, 字符串) - 在字符串中去获取符合正则表达式条件的所有的子串，返回的是一个列表
"""
str1 = 'sdaf654da654f6a4f6af46a4f+a4f6a'
print(re.findall(r'\d+', str1))
print(re.findall(r'f(\d+)', str1))

"""
c.重复匹配
带多个分组的正则表达式，可以在分组的后面通过添加'\数字'来重复前面第几个分组中匹配到的内容

说明：\数字 - 这儿的数字代表前面第几个分组；\1代表第一个分组， \2代表第二个分组
"""
re_str = r'(\d{3})([a-z]{2})a\1\2'
print(re.fullmatch(re_str, '123qqa123qq'))

3.贪婪

"""
匹配次数后加?就是贪婪匹配：*?, +?, ??, {}? - 表示尽可能少的重复
"""
re_str = 'a.+?b'
str1 = 'xxxahdbsdffagvbsx'
print(re.findall(re_str, str1))

4.转义符号

"""
在正则表达式中可以在有特殊意义或者特殊功能的符号前加‘\’来取消其特殊的功能
\w - 代表两个字符，分别是'','w'
+ - 代表'+'字符
[],(),{}表示字符的时候，前面也要加
...
注意：在中括号中，\加\表示\本身，^{在最前面加\表示}本身，-在两个字符之间加\表示-本身
"""
re_str = r'\w-\d{3}'
print(re.fullmatch(re_str, '\w-232'))

反斜杠个数除以2，得到的结果如果有小数部分则整数部分加1

print('\\\w-123')

4.re模块

import re

1.complie

"""
complie(正则表达式) - 将正则表达式转换成正则表达式对象
转换成对象后可以通过对象调用对象方法

"""
re_str = '\d{3}'
re_obj = re.compile(re_str)

调用模块中的函数

print(re.fullmatch(re_str, '234'))

调用对象方法

print(re_obj.fullmatch('234'))

2.match和fullmatch

"""
a.fullmatch(正则表达式, 字符串) - 完全匹配，从字符串开头匹配到字符串结束
b.match(正则表达式, 字符串) - 不完全匹配，只匹配到字符串开头
"""
re_str = r'\d[A-Z]{2}'
result = re.fullmatch(re_str, '2HK')
print(result)

re_str = r'\d([A-Z]){2}'
result1 = re.match(re_str, '8KLdfa')
print(result1)

匹配对象

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

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

"""
3.group - 获取匹配到的内容
匹配对象.group() - 获取整个正则表达式匹配到的内容
匹配对象.group(n)- 获取正则表达式第n个分组匹配到的范围
"""
print(result1.group())
print(result1.group(1))

"""
4.string - 获取用来匹配的原字符串
匹配对象.string
"""
print(result1.string)

3.search

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

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

4.split

"""
split(正则表达式, 字符串) - 在字符串中按照满足正则表达式条件的子串对字符串进行切割
返回是一个列表
"""
str1 = 'ab+1da35sf13_a1f35sd1g3a'
result = re.split(r'\d+', str1)
print(result )

5.sub

"""
sub(正则表达式, 新子串, 字符串) - 用新子串替换字符串中满足正则表达式的子串，返回一个替换后的字符串
"""

6.findall

"""
findall(正则表达式, 字符串) - 在字符串中获取满足正则表达式的所有的字符，返回一个列表，列表元素是字符串

注意：如果正则表达式中有一个分组，结果是列表中只取这个分组匹配到的结果
如果这个正则表达式中分组个数大于1，结果就是一个列表，列表中的元素就是元组，元组中是每个分组匹配到内容
"""

7.finditer

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