1.正则基本符合

1.1.什么是正则表达式

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

1.2.python对正则表达式的支持

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

1.2.1普通字符

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

from re import fullmatch
#匹配一个字符串第一个字符是a，第二个字符是b，第三个字符也是最后一个字符c
re_str = r'abc'
result = fullmatch(re_str,'abc')
print(result) #<re.Match object; span=(0, 3), match='abc'>

1.2.2 ‘.’（匹配任意字符）

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

#匹配一个长度是3的字符串，并且第一个字符是a，最后一个字符是C，中间是任意字符
re_str = r'a.c'
result = fullmatch(re_str,'a\tc')
print(result) #<re.Match object; span=(0, 3), match='axc'>

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

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

• 注意一个\w只能匹配一个字符
  中文也能匹配

re_str = r'a\wc'
result = fullmatch(re_str,'a哈c')
print(result) #<re.Match object; span=(0, 3), match='a哈c'>

1.2.4.\s（匹配空白字符）

空白字符包括：空格、制表符和换行符（空格、\t ,\r ,\n）

re_str = r'a\s\sc'
result = fullmatch(re_str,'a\t\nc')
print(result) # <re.Match object; span=(0, 4), match='a\t\nc'>

1.2.5 \d (匹配数字字符)

re_str = r'a\d\d.\w'
result = fullmatch(re_str,'a78c_')
print(result) #<re.Match object; span=(0, 5), match='a78c_'>

1.2.6 \b(检查单词边界)

• 注意：\b 是检测\b出现的位置是否是单词边界，不会对字符进行匹配
  当正则表达式中出现了\b 匹配时先去掉\b，匹配成功后在看\b出现的位置是否是单词边界
  单词边界：字符串开头，字符串结尾，标点符号，空白符号，可以将两个单词隔开的字符都是单词边界

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

1.2.7 ^(检测字符串开头)

• 在match和fullmatch中没有意义，但在search、findall等中有意义

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

1.2.8 $ (检测字符串结尾)

在match和fullmatch中没有意义，但在search、findall等中有意义

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

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

1.2.9 \W（匹配非数字字母下划线）

re_str =r'.\WThe'
result = fullmatch(re_str,'嘿\tThe')
print(result)

#匹配一个字符串，第一个是数字，第二个是非数字，第三个是空白，第四个是数字字母下划线，最后一个是a，并且要求a的前面不是单词边界

re_str =r'\d\d\s\w\Ba'
result = fullmatch(re_str,'99\t_a')
print(result)

1.2.10 [字符集]（匹配中括号中出现的任意一个字符）

• 1.[普通字符集]（匹配中括号中出现的任意一个字符）
  例如:[abc] - 匹配一个字符是a或者b或者c

• 注意：a.一个字符串只能匹配一个字符
  b.正则表达式中有特殊功能的单个符号在中括号中都表示本身例如：. $ ^ * + ? | 等
  c.匹配早饭的组合符号，在中括号中保持原来的功能，例如：\w,\d,\s,\W ,\D,\S

#匹配一个长度是2的字符串，第一个字符是数字，第二个字符是b或者c或者d
re_str = r'\d[bcd]'
result = fullmatch(re_str,'8b')
print(result)

• 2.[字符1-字符2] - 表示字符1到字符2（注意：字符1的编码值小于字符2的编码）

[a-z] - 表示匹配所有的小写字母
[A-Z] - 表示匹配所有的大写字母
[a-zA-Z] - 表示匹配所有的字母
[1-7] - 匹配数字字符1到7
[\u4e00-\u9fa5] - 匹配所有的中文
[字符1字符2-] - 这儿的-表示减号本身

re_str = r'[1-7][a-z]'
result = fullmatch(re_str,'5s')
print(result)

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

#匹配除了1-7和a-z的任意一个字符
re_str = r'[^1-7][^a-z]'
result = fullmatch(re_str,'8哈')
print(result)

2.正则控制匹配次数

1. *(匹配0次或者多次)

• a* - a出现0次或者多次, '','a','aa', 'aaa'...都可以匹配

• \d* - 任意数字出现0次或者多次， '','1','12', '3772'...都可以匹配

• [abc]* - a，b或者c出现0次或者多次

• [A-F]* - A到F中任意字符出现0次或者多次

• 注意：在[]外面的*的前面需要一个字符或者一个匹配字符的符号

print(re.fullmatch(r'a*b', 'aaaaaaaaaab'))
print(re.fullmatch(r'[abc]*', 'aabc'))

2 +(匹配1次或者多次)

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

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

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

• a? - a出现0次或者1次, '', 'a'可以匹配

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

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', 'aaaaa'...

print(re.fullmatch(r'a{3,}', 'aaa'))

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

4.捕获和贪婪

1.分之

条件1 | 条件2 - 匹配条件1或者条件2
\d{2}|[a-z] - 匹配两个数字字符或者一个小写字母
a\d{2}|\w{2} - 匹配一个a后面两个数字，或者两个数字字母下划线

• 注意：正则中的分之也会出现短路，当条件1可以匹配，就不会再使用条件2进行匹配

print(re.fullmatch(r'\d{2}|[a-z]', 'z'))
print(re.fullmatch(r'a\d{2}|\w{2}', 'sh'))

# 练习：写一个正则表达式，匹配所有的数字,包括正的、负的，整数，小数，0
# 例如：100, +100, -100, 12.5, -12.5, 0, 0.23, 0.012
"""
12, 12.34 : [+-]?[1-9]\d*[.]?\d*
0.123 : [+-]?0[.]\d+ 
0 : 0
"""
re_str = r'[-+]?[1-9]\d*[.]?\d*|[+-]?0[.]\d+|0'
print(re.fullmatch(re_str, '-0.02'))

2 () - 捕获和分组

• 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'))

# 匹配一个字符串，以'数字小写字母'的形式出现3次
re_str = r'(\d[a-z]){3}'
print(re.fullmatch(re_str, '2s3f4h'))

• b.捕获

• 通过正则获取符合条件的子串的时候，可以在正则表达式中加括号，匹配后只获取括号里面匹配到的内容

• re.findall(正则表达式，字符串) - 在字符串中去获取符合正则表达式条件的所有的子串,返回一个列表

str1 = 'ahsa783+sdh*92dfjhjj78jhsda67jk'
print(re.findall(r'a(\d+)', str1))  # ['783', '67']

c.重复匹配

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

• 说明：\数字 - 这儿的数字代表前面第几个分组; \1代表第一个分组 \2代表第二个分组

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

3.贪婪

• 匹配次数后加?就是贪婪匹配：*?, +?, ??, {M,N}?, {M,}? 表示尽可能少的重复

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

with open('content.txt', encoding='utf-8') as f:
    text = f.read()
    re_str = '"name":(.+?),'
    all_names = re.findall(re_str, text)
    print(all_names)

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

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

5.re模块

1.compile

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

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

print(re.fullmatch(re_str,'123'))#调用模块中的函数
print(re_obj.fullmatch('132'))#调用对象方法

2.match和fullmatch

a.fullmatch(正则表达式，字符串) - 完全匹配，从字符串开头匹配带字符串结束

b.match（正则表达式，字符串） - 不完全匹配，只匹配字符串开头

匹配成功返回匹配对象，失败返回None

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

result2 = re.match(re_str,'3KS4123sda ')
print(result2)

匹配对象

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

print(result2.span())
print(result2.span(1))

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

print(result2.start())
print(result2.end())
print(result2.start(1))
print(result2.end(1))

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

print(result2.group())
print(result2.group(1))

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

print(result2.string)

3.search

• search(正则表达式，字符串) - 匹配字符串中第一个满足正则表达式的子串，如果匹配成功返回子串，失败返回None

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

4.split

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

str2 = 'ab+c1d32as2dasdas1d4a*as'
result = re.split(r'\d+',str2)
print(result) #['ab+c', 'd', 'as', 'dasdas', 'd', 'a*as']

5.sub

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

str3 = '你是傻逼吗，操你大爷的'
result = re.sub(r'[傻逼操]|大爷','*',str3)
print(result)#你是**吗，*你*的

6.findall

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

str4 = 'sd1234asd1asda1daa23asd4as45das54=='
result = re.findall(r'[a-zA-Z]{2,}(\d+)([a-z]+?)',str4)
print(result)

7.finditer

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

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

#思考  写一个自己的finditer
def my_finditer(pattern,string):
    re1 = re.search(pattern,string)
    while re1:
        yield re1
        s = re1.end()

        re1 = re.search(pattern,string[s:])
print('============')
result = my_finditer(r'[a-zA-Z]{2,}(\d+)([a-z]+?)',str4)
print(next(result))
print(next(result))
print(next(result))