1.正则表达式

1.1什么是正则表达式

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

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

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

1.3 普通字符

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

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

1.4 .（匹配任意字符）

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

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

1.5 \w（匹配字母数字或者下划线）

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

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

1.6 \s（匹配空白字符）

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

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

1.7 \d（匹配数字字符）

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

1.8 \b（检测单词边界）

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

re_str=r'hello\bworld'
result=re.fullmatch(re_str,'hello world')
print(result) #None

re_str=r'\bhello，\bworld'
result=re.fullmatch(re_str,'hello，world')
print(result)

1.9 ^(检测字符串开头)

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

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

# search中有意义
print(re.search(re_str,'xxxxThe23'))  # None

1.10 $（检测字符串结尾）

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

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

print(re.search(re_str,'xxThexx')) # None

1.11 \大写字母

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

# 匹配一个字符串，第一个字符是数字、第二个是非数字，第三个是空白，第四个是空白，最后一个a，
# 并且要求a前面不能是单词边界
re_str=r'\d\D\s\s\Ba'
print(re.fullmatch(re_str,'2a  a')) # None  a前面是两个空白，但要求不能是单词边界，所以是None

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

1.12.1.[普通字符集] （匹配中括号出现的任意一个字符）

例如：[abc] - 匹配一个字符是a或者b或者c
注意：
a.一个中括号只能匹配一个字符,
b.正则表达式中有特殊功能的单个（例如.$^+?|等）符号放中括号里面失去原有的功能，变成普通符号;
c.匹配字符的组合符号（\d，\w,\s等），在中括号中仍然保持原有特殊意义.*

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

1.12.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中的一个，
# 第二个是abc-中的一个，第三个是小写字母
re_str=r'[1-7][abc-][a-z]'
result=re.fullmatch(re_str,'3-b')
print(result)

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

[^abc] - 匹配除了a，b，c以外的任意一个字符
[^\d] - 匹配除了数字字符以外的其他任意一个字符
[^a-z] - 匹配除了小写字母以外的其他任意一个字符
[abc^] -匹配abc^中的任意一个字符.

re_str=r'[^a-z]'
result=re.fullmatch(re_str,'是')
print(result) # 是

2 正则控制匹配次数

2.1 *(匹配0次或者多次)

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

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

2.2 +（匹配1次或者多次）

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

print(re.fullmatch(r'a+b','aaaaaaaab')) # 没有a不能匹配

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

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

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

2.4{}

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

# 输入密码，要求检测密码输入是否合格（密码由数字和字母组成，数字不开头，6-12位）
re_str=r'[a-zA-Z][\da-zA-Z]{5,11}'
str1=input('请输入密码（6-12位），不能以数字开头:')
result=re.fullmatch(re_str,str1)
if result:
    print('密码正确')
else:
    print('密码错误')

3 分之、捕获和贪婪

3.1 分之

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

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

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

3.2 捕获和分组

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

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

3.2.2 捕获

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

str1='ahs123+34asdf24'
print(re.findall(r'\d+',str1)) # ['123', '34', '24']

str2='a153s123+34asfa24'
print(re.findall(r'a\d+',str2))  # ['a153', 'a24']
print(re.findall(r'a(\d+)',str2)) # ['153', '24']

3.2.3重复匹配

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

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

3.3 贪婪

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

re_str='a.+b' # 以a和b结尾，中间字符任意个
re_str1='a.+?b'
str1='xxahdjbnnkhasssbkkkkk'
print(re.findall(re_str,str1)) # ['ahdjbnnkhasssb'] 普通方法
print(re.findall(re_str1,str1)) # ['ahdjb', 'asssb'] 贪婪方法

#从一个json文件中提取出人们的名字（名字以”name“开头，接着是：后面是要提取的内容，名字以逗号结尾）
with open('file',encoding='utf-8') as f:
    text=f.read()
    re_str='"name":(.+?),'  # 用贪婪方法能将每个人的名字分开，而不是提取出的第一个name到最后一个逗号中的全部内容
    all_names=re.findall(re_str,text)
    print(all_names)

3.4 转义字符

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

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

4 re模块

4.1 complie

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

re_str=r'\d{3}'
re_obj=re.compile(re_str)
# 调用模块中的函数
print(re.fullmatch(re_str,'243'))
# 调用对象方法
print(re_obj.fullmatch('234'))

4.2 match和fullmatch

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

re_str=r'\d[A-Z]{2}'
result1=re.fullmatch(re_str,'2HKsif')
print(result1) # None
result2=re.match(re_str,'8KLsifdfd==')
print(result2) # '8KL'

4.3匹配对象

4.3.1 span

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

print(result2.span()) # (0, 3)
print(result2.span(1))

4.3.2start和end

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

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

4.3.3group

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

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

4.3.4 string

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

print(result2.string)

4.4 search

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

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

4.5 split

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

str1='ab+c7hdjd8jss-sk9s9kk*k'
result=re.split(r'\d+|[+*-]+',str1)
print(result) # ['ab', 'c', 'hdjd', 'jss', 'sk', 's', 'kk', 'k']

4.6 sub

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

str1='你压是傻叉吗'
result=re.sub(r'[压]|[傻叉]','*',str1)
print(result) # 你*是**吗

4.7findall

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

str1='haja37jjkd89sdhs909nnna238==='
result=re.findall(r'[a-zA-Z]{2,}\d+[a-z]+',str1)
print(result) # ['haja37jjkd', 'sdhs909nnna']

str1='haja37jjkd89sdhs909nnna238==='
result=re.findall(r'[a-zA-Z]{2,}(\d+)([a-z]+?)',str1)
print(result) # [('37', 'j'), ('89', 's'), ('909', 'n')]

4.8 finditer

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

str1='haja37jjkd89sdhs909nnna238==='
result=re.finditer(r'[a-zA-Z]{2,}(\d+)([a-z]+?)',str1)
print(result)
print(next(result)) # span=(0, 7), match='haja37j'

自己实现 finditer方法：

def yt_finditer(pattern,string):
    re1=re.search(pattern,string)
    while re1:
        yield re1
        string=string[re1.end():]
        re1=re.search(pattern,string)
result=yt_finditer(r'[a-zA-Z]{2,}(\d+)(a-z)+?',str1)
print(next(result))