1.什么是正则表达式

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

2.python对正则表达式的支持。

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

1.普通字符

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

#匹配字符串，第一个字符a，第二个字符b，第三个字符也是最后一个字符“c”
re_str = r"abc"
result = re.fullmatch(re_str,"abc")
print(result)

3 . (匹配任意字符)

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

re_str = r"a.c"
result = re.fullmatch(re_str,"ahc")
print("....",result)

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

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

#匹配一个长度是6的下划线,前三位字母数字中文等，后面是任意字符i字符
re_str = r"\w\w\w..."
result = re.fullmatch(re_str,"_5禹dsa")
print("\w",result)

5 \s匹配空白字符

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

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

6 \d（匹配数字字符）

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

7 \b(检测单词边界)

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

#匹配字符串“hello，word并且要求w前面是单词边界”
re_str = r"hello,\bword"
result = re.fullmatch(re_str,"hello,word")
print(result)

8^ 检测字符串开头

match和fullmatch中没有意义，serach和findall中有意义.

#匹配一个字符串前面三个是The，后面两个任意字符
re_str = r"^The.."
result = re.fullmatch(re_str,"The2a")
print(result)
re_str = "The.."
print("search：",re.search(re_str,"xxxThe2："))

9 $(检测字符串中结尾)

match和fullmatch中没有意义，serach和findall中有意义.

re_str =r"..\dThe$"
result = re.fullmatch(re_str,"aa5The")
print("$",result)
re_str =r"..\dThe"  #没有$
print("search：",re.search(re_str,"aa5Thesad"))

\大写字母 对应的功能格式 \小写字母 功能区分

\W - 匹配非数字字母下划线

\D - 匹配非数字字符

\S - 检测非空白字符

\B - 检测非单词边界

re_str = r"\d\D\s\s\Ba"
result = re.fullmatch(re_str,"94\t\ta")
print("前面有一个\s是单词边界：",result) #前面有一个\s是单词边界： None

re_str = r"\d\D\s\w\Ba"
result = re.fullmatch(re_str,"9h\t_a")
print("\B前面有一个不是单词边界：",result)

---	---
[字符1 - 字符2]	表示字符1到字符2（注意：要求字符1的编码值要小于字符2的编码值。）
[a-z]	表示匹配所有小写字母
[A-Z]]	匹配所有的大写字母
[a-zA-Z]	匹配所有字母
[\u4e00 - \u9fa5]
[字符1字符2-]	这儿的减号就表示减号本身

re_str = r"[1-7]100[a-z]"
result = re.fullmatch(re_str,"5100g")
print("[字符1 - 字符2]11",result)
#匹配1-7的数字字符，第二个是abc-中的一个，第三个是小写字母
re_str = r"[1-7][abc-][a-z]"
result = re.fullmatch(re_str,"5-z")
print("[字符1 - 字符2]22",result)

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

---	---
[^abc]不是abc
[^\d]	除了数字字符的任意字符
[^a-z]	匹配除小写的其他任意字符
[abc^]	这里的^ 表示 ^。

.#三个字符，第一个不是1-7，第二个不是abc-，第三个不是a-z
re_str = r"[^1-7][^abc-][^a-z]"
result = re.fullmatch(re_str,"0H罗")
print("^[字符1 - 字符2]22",result)

2。正则控制匹配次数

1.匹配0次或多次

---	---
a*]a出现0次或者多次 "","a","aa"
\d*	任意数字出现多次或者零次
[abc]*	abc出现0次或者多次
[A-F]*	A到F中任意字符出现多次或者0次

注意哦：在[ ]外面的前面需要一个字符或者一个匹配字符的符号，不能单独用*

print(re.fullmatch(r"a*",""),re.fullmatch(r"a*",""))
print(re.fullmatch(r"a*b","aaab"),re.fullmatch(r"a*b","aaab"))
print("\d*",re.fullmatch(r"\d*","12563"))
print("[abc]*",re.fullmatch(r"[abc]*","abc"),re.fullmatch(r"[abc]*","aaa"))

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

a+ - a至少出现1次
\d+ -数字字少出现一次

print("a+",re.fullmatch(r"a+b","ab"),re.fullmatch(r"a+b","aaab"))

3 ? (出现0次或者1次)

a? - a出现0次或者1次，“”，“a”可以匹配

# 写出一个正则表达式（整数和负数都可以匹配）例如：123，-120
re_str = r"[-+]?[1-9]\d*"
result = re.fullmatch(re_str,"+30")
print("整数和负数都可以匹配",result)

4.{ }的用法

{N} - 匹配N次，a{3}：匹配3个“a”
{M，N} - 匹配M到N次，匹配三个a，四个a，或者5个a
{，N}- 最多匹配N次（0-N） 例如：a{，3}“”，“a”，“aa”"aaa"
{M，} - 至少匹配M次

#练习：输入密码。密码要求，字母和数字组成，数字不开头，6-12位，给出提示是否正确
pw = input("输入密码：")
re_str = r"[a-zA-Z][\da-zA-Z]{5,11}"
result = re.fullmatch(re_str,pw)
print(result)
if result:
    print("输入成功！")
else:
    print("输入有误！")

3捕获与贪婪

1 分之.

条件1 | 条件2 ：匹配条件1或者条件2.
\d | [a-z] - [\da-z]
\d{2} | [a-z] ：匹配两个数字或者1个a-z
a\d{2}|\w{2}
** 注意：正则中的分之也会出现短路，当条件1可以匹配，就不会再用第二个匹配**

print("分之",re.fullmatch(r"\d{2}|[a-z]","z"))
print("分之",re.fullmatch(r"a\d{2}|\w{2}","__"))

# 习：写一个正则表达式，匹配所有的数。正的，负数，0
re_str = r'[-+]?[1-9]\d*[.]?\d*|[+-]?0[.]\d+|0'
print(re.fullmatch(re_str, '-0.02'))

4 - 捕获和分组

• a.分组 - 将括号中的内容作为一个整体

# 匹配一个字符串，前三位是'abc',后三位是三个数字或者三个大写字母
re_str1 = r'abc\d{3}|abc[A-Z]{3}'
re_str2 = r'abc(\d{3}|[A-Z]{3})'
print(re.fullmatch(re_str2, 'abc123'))

re_str = r'(\d[a-z]){3}'
print(re.fullmatch(re_str, '2s3f4h'))

• b.捕获
  通过正则表达式获取符合条件的子串的时候，可以在正则表达式中加括号，匹配后只获取括号里面出现的内容
  re.findall（正则表达式，字符串） - 在字符串中去获取符合正则表达式条件的所有子串，返回的是列表

str1 = "dasdad454a13ada2x1ad56a44g4fdad"
# 捕获括号中的内容
print(re.findall(r"a\d+",str1))
print(re.findall(r"a(\d+)",str1))

• c.重复匹配
  带多个分组的正则表达式中可以分组的后面通过添加\数字来重复前面第几个分组中匹配到的内容.
  说明：\数字 - 这儿的数字代表前面第几个分组\1代表第一个分组，\2代表一个分组

re_str = r"\d{3}([a-z]{2})a\1"
print("第一分组重复",re.fullmatch(re_str,"234heahe"))
re_str = r"(\d{3})([a-z]{2})a\1{2}\2"
print("第一分组重复2，第一分组重复1",re.fullmatch(re_str,"123bba123123bb"))
re_str = r"(\d{3})L\1{2}([a-z]{2})a\2"
print("分组重复可以放前面去",re.fullmatch(re_str,"123L123123bbabb"))

3.贪婪

匹配次数后面加？就是贪婪匹配“*？，+？，??.{M,N}？,{M,}？

re_str = "a.+b"
str1 = "xxxahdjblkaluiihjlb"
print("非贪婪",re.findall(re_str,str1))

re_str = "a.+?b"
str1 = "xxxadfgjblkaluibihjalb"
print("贪婪",re.findall(re_str,str1))

4 转义字符

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

在正则表达式中可以在有特殊意义或者特殊功能的符号前加\来取消其特殊功能
\\w  - 代表两个字符，分别是'\'和w
\+ - 代表+字符
\* - 代表*字符
\? - 代表?字符
[], (), {}表示字符的时候，前面也要加\

注意：在中括号中, \必须加\表示\本身，^在最前面加\表示^本身， -在两个字符之间加\表示-本身

re_str = r'\\w-\d{3}'
print(re.fullmatch(re_str, '\w-232'))

re_str = r'a\+\(\d{2}\)'
print(re.fullmatch(re_str, 'a+(23)'))

re_str = r'[\^a1\-9]'
print(re.fullmatch(re_str, '3'))

3.re模块

1.compile(了解)

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

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(正则表达式, 字符串) - 不完全匹配，只匹配字符串开头
  匹配成功返回匹配对象，匹配失败返回None

re_str = r"\d[A-Z]{2}"
result = re.match(re_str,"8HHdjadnksan")
print("只是匹配字符串开头：",result)

匹配对象特别篇

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

re_str = r"\d([A-Z]{2})"
result = re.match(re_str,"8HHdjadnksan")
print("整个范围",result.span())
print("匹配对象的范围",result.span(1))

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

re_str = r"\d[A-Z]{2}"
result = re.match(re_str,"8HHdjadnksan")
print("开始下标",result.start())
print("结束下标",result.end())
re_str = r"\d([A-Z]{2})"
result = re.match(re_str,"8HHdjadnksan")
print("分组开始下标",result.start(1))
print("分组结束下标",result.end(1))

• 3.group - 获取匹配到的内容
  匹配对象.group（） - 获取正则表达式匹配带的内容
  匹配对象.group（n） - 获取正则表达式第n个分组的内容

re_str = r"\d([A-Z]{2})"
result = re.match(re_str,"8HHdjadnksan")
print("整个表达式结果",result.group())

re_str = r"\d([A-Z]{2})"
result = re.match(re_str,"8HHdjadnksan")
print("第一组的结果",result.group(1))

• 4.string - 获取用来匹配的原字符串
  匹配对象.string

re_str = r"\d[A-Z]{2}"
result = re.match(re_str,"8HHdjadnksan")
print("整个表达式结果",result.string)

3.search

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

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

4.split(正则表达式，字符串)

split(正则表达式，字符串) - 在字符串中，按照满足正则表达式条件的子串对字符进行切割

str1 = "ads5had5f-ha9rda6adg"
result = re.split(r"\d+",str1)
print("split切割：",result)
result = re.split(r"\d+|[+*-]+",str1)
print("split切割：",result)

5 sub（正则表达式，新子串，字符串）

sub（正则表达式，新子串，字符串）用新的字符串替换字符串中满足正则表达式的子串，返回一个替换后的子串

str1 = "你是傻   叉，操你大爷的，Fuck you"
result = re.sub(r"[丫艹操]|[Fuck]|傻\s*叉","*",str1)
print("sub替换：",result)

6.findall(正则表达式，字符串) - 在字符串中获取满足正则表达式的所有字符串，返回一个列表
列表元素是字符串
注意：
正则表达式中有一个分组，结果是列表中只取分组匹配到的结果。
如果正则表达式分组的个数大于1，结果是一个列表，列表中的元素是元组

str1 = "dafdd5as45d4ad4as4d54sg545f4j5h4j54ds=="
result = re.findall(r"[a-zA-Z]{2,}\d+[a-z]+",str1)
print("不加贪婪",result)
str1 = "dafdd5as45dds4ad4as4dda54dasg545f4j5h4j54ds=="
result = re.findall(r"[a-zA-Z]{2,}(\d+)([a-z]+?)",str1)
print("加贪婪",result)
str1 = "dafdd5as45d4ad4as4d54sg545f4j5h4j54ds=="
result = re.findall(r"[a-zA-Z]{2,}(\d+)([a-z]+?)",str1)
print("加括号元组",result)

7.finditer(正则表达式，字符串)

获取字符串中满足正则表达式的内容，返回结果是一个迭代器
迭代器中的元素就是匹配对象

str1 = "dafdd5as45d4ad4as4d54sg545f4j5h4j54ds=="
result = re.finditer(r"[a-zA-Z]{2,}\d+[a-z]+",str1)
print("finditer迭代器",result)
print(next(result))

\
#思考 ：写一个自己的finderiter
def yt_finditer(patteran,string):
    re1 = re.finditer(patteran,string)
    while re1:
        yield re1
        string = string[re1.end():]
        re1 = re.finditer(patteran, string)
str1 = "dafdd5as45d4ad4as4d54sg545f4j5h4j54ds=="
result = yt_finditer(r"[a-zA-Z]{2,}\d+[a-z]+",str1)
print("取结果",next(result))