day18-课后总结

正则表达式

1.正则表达式语法

python中通过re模块中相应的方法来支持正则表达式的匹配、查找和替换的功能

from re import fullmatch

fullmatch(正则表达式，字符串) -->判断正则表达式和字符串是否完全匹配
正是表达式字符串：就是一个字符串，字符串是正则表达式语法。r'正则表达式'
正则表达式包含两个部分，一是正则语法对应的字符，二是普通字符
转义字符代表一个字符\n
a. '.'(匹配任意的字符)
一个.只匹配一个字符

# 匹配一个长度是3的是字符串，第一个字符是’a‘，第二个字符时任意字符，最后一个字符是'b'
re_str = r'a.b'
result = fullmatch(re_str, r'a2b')
print(result) #<_sre.SRE_Match object; span=(0, 3), match='a2b'>

b. '\w'(匹配字母数字下划线)
一个\w匹配一个字符

# 匹配一个第一个字符是数字字母或者下划线，后面三个字符是任意字符的字符串
re_str = r'\w...'
result = fullmatch(re_str, '_879')
print(result) # <_sre.SRE_Match object; span=(0, 4), match='_879'>

c.'\s'(匹配任意空白字符)
空白字符：空格、制表符、回车(换行)等，都输入空白字符
一个\s匹配一个空白字符

# 匹配一个第一个字符是a，第二个字符是空白，最后一个字符b的字符串
re_str = r'a\sb'
result = fullmatch(re_str, 'a\tb')
print(result) # <_sre.SRE_Match object; span=(0, 3), match='a\tb'>

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

re_str = r'\d\d\d'
result = fullmatch(re_str, '283')
print(result) # <_sre.SRE_Match object; span=(0, 3), match='283'>

e.'\b'(检测边界)
一个\b不回去匹配一个字符，而是单纯的检测\b出现的位是是否是单词边界
单词边界：字符串开头和结尾、空格、换行、标点符号等，可以将两个单词隔开的字符都是单词边界

re_str = r'\babc'
re_str = r'abc\b\saaa'  # 匹配一个字符串前三位是abc，第四位是空白字符，后面是aaa，并且要求c后面是单词边界
result = fullmatch(re_str, 'abc aaa')
print(result)
# <_sre.SRE_Match object; span=(0, 7), match='abc aaa'>

f.'^'(检查是否是字符串的开头)

re_str = r'^\d\d\d'  # 判断一个字符串是三个数字开头
result = fullmatch(re_str, '445')
print(result)
# <_sre.SRE_Match object; span=(0, 3), match='445'>

g. '$'(检查是否是字符串结尾)

re_str = r'abc$'
result = fullmatch(re_str, 'abc')
print(result)
# <_sre.SRE_Match object; span=(0, 3), match='abc'>

h.'\W'(匹配非字母数字下划线)

re_str = r'\Wabc'
result = fullmatch(re_str, '#abc')
print(result)
<_sre.SRE_Match object; span=(0, 4), match='#abc'>

i. '\S' (匹配非空白字符)

re_str = r'\S...'
result = fullmatch(re_str, 'cdas')
print(result)
# <_sre.SRE_Match object; span=(0, 4), match='cdas'>

j. '\D'(匹配非数字字符)

re_str = r'\D\w\w\w'
result = fullmatch(re_str, '*5g_')
print(result)
# <_sre.SRE_Match object; span=(0, 4), match='*5g_'>

k. '\B'(检测是否不是单词边界)

re_str = r'and\BYOU'
result = fullmatch(re_str, 'andYOU')
print(result)
# <_sre.SRE_Match object; span=(0, 6), match='andYOU'>

L .'[]'(匹配中括号中出现的任意一个字符)
一个[]匹配一个字符

re_str = r'[1-8]\d\d\d'
result = fullmatch(re_str, '6123')
print(result)
# <_sre.SRE_Match object; span=(0, 4), match='6123'>

m.'[^字符集]'（匹配一个不在字符集中的任意字符）
^必须放在中括号中的最前面才有效

# 匹配一个四位的字符串，第一位不能是abc中的任意一个，后面三位是任意字符
re_str = r'[^abc]...'
print(fullmatch(re_str, '5fhf'))

2.正则表达式次数相关符号

from re import fullmatch

a.'*'(匹配0次或者多次)
字符*--->前面这个字符出现0次或者多次

# 匹配0位或者多位的数字字符串
re_str = r'\d*'
result = fullmatch(re_str, '')
print(result)
# <_sre.SRE_Match object; span=(0, 0), match=''>

b.'+'(匹配一次或者多次)

# abc前面有一个或则多个的数字的字符串
re_str = '\d+abc'
result = fullmatch(re_str, '12abc')
print(result)
# <_sre.SRE_Match object; span=(0, 5), match='12abc'>

c.'?'(0次或者1次)

re_str = r'a?123'
result = fullmatch(re_str, 'a123')
# result = fullmatch(re_str, '123')
print(result)

d.'{}'(指定次数)

{N}--   匹配N次
{M,N}-- 匹配M到N次
{M,}--  至少匹配M次
{,N}--  最多匹配N次

# 判断密码是否符合要求
re_str = r'[a-zA-Z\d]{6,16}'
result = fullmatch(re_str, '2222418')
print(result)

3.分之和分组

a.'|'（分之）
条件1|条件2 --> 先用条件1去匹配，如果匹配成功就匹配成功。如果条件1匹配失败，用条件2去匹配。
注意：如果条件1匹配成功就不会用条件2再去匹配

re_str = r'[a-z]{3}|[A-Z]{3}'
print(re.fullmatch(re_str, 'AHD'))

# 能匹配成功abc，d和aaa
re_str = r'abc|d|aaa'
print(re.fullmatch(re_str, 'aaa'))
# 'abc'+W/H/Y
re_str = r'abc(W|H|Y)'
print(re.fullmatch(re_str, 'abcY'))

b. '()'(分组)
1.组合（将括号中的内容作为一个整体操作）
2.捕获-->使用带括号的正则表达式匹配成功后，只回去括号中的内容
3.重复 -->在正则表达式中可以通过\数字来重复前面()中匹配到的结果。数字代表前第几个分组

组合
# 匹配一个字符串，以数字字母的组合出现3次
re_str = r'(\d[a-zA-Z]){3}'
print(re.fullmatch(re_str, '2h8h7j'))

捕获
re_str = r'(\d{3})abc'
print(re.fullmatch(re_str, '773abc'))
print(re.findall(re_str, 'euhasdhf873abcssjsja235abcu-03s834432abcjjsks'))
# ['873', '235', '432']

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

c.转义符号
正则表达式中可以通过在特殊的符号前+\，来让特殊的符号没有意义

. --> 任意字符  \. --> 字符.
+ --> 匹配一次或者多次   \+ --> 字符+

在中括号中有特殊功能的符号，只代表符号本身
\不管在哪儿都需要转义
-在[]外面没有特殊功能，在[]中要表示-本身，就不要放在两个字符之间
()需要转义

re_str = r'\d{2}\.\d{2}'
print(re.fullmatch(re_str, '12=34')) # None

re_str = r'\d\+\d'
print(re.fullmatch(re_str, '3+7'))

re_str = r'\(\\'
print(re.fullmatch(re_str, '(\\'))# <_sre.SRE_Match object; span=(0, 2), match='(\\'>

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

4.re模块中的函数

import re

a.'comile'
comile(正则表达式字符串)-->将正则表达式字符串转换成正则表达式对象

re_objct = re.compile(r'\d+')
print(re_objct)
print(re_objct.fullmatch('23738'))

b.fullmatch和match
fullmatch(正则表达式字符串, 字符串)
--> 用正则表达式去完全匹配字符串(匹配整个字符串)，返回匹配对象(SRE_Match)或者None

match(正则表达式字符串, 字符串)
--> 匹配字符串开头,返回匹配对象或者None

result = re.match(r'\d([a-zA-Z]+)123', '2hjdh123ABC')
print('match:',result)# match: <_sre.SRE_Match object; span=(0, 8), match='2hjdh123'>

result = re.fullmatch(r'\d([a-zA-Z]+)123', '2hjdh123ABC')
print('match:',result) # None

result = re.fullmatch(r'\d([a-zA-Z]+)123', '2hjdh123')
print(result)
# 1.span(group=0) --> 获取匹配成功的区间(左闭右开区间)
print(result.span())
print(result.start(1))   # 获取匹配到的开始下标
print(result.end(1))     # 获取匹配到的结束下标后的下标

# 2.group(group = 0) --> 获取匹配结果
"""
group()/group(0) --> 获取正则表达式完全匹配的结果
group(index>0) --> 获取正则表达式中第group个分组匹配到的结果
"""
print('0:',result.group())
print('1:',result.group(1))
# 3.string --> 获取被匹配的原字符串
print(result.string)

c.search
search(正则表达式，字符串)
查找字符串中满足正则表达式的第一个字符串。返回值是匹配对象或None

# 练习：使用search匹配出一个字符串中所有的数字字符串
# 'abc34jshd8923jkshd9lkkk890k' --> 34，8923，9，890
re_str = r'\d+'
str1 = 'abc34jshd8923jkshd9lkkk890k'
result = re.search(re_str, str1)
while result:
    print(result)
    str1 = str1[result.end():]
    result = re.search(re_str, str1)
<_sre.SRE_Match object; span=(3, 5), match='34'>
<_sre.SRE_Match object; span=(4, 8), match='8923'>
<_sre.SRE_Match object; span=(5, 6), match='9'>
<_sre.SRE_Match object; span=(4, 7), match='890'>

d.findall
findall(正则表达式, 字符串) --> 获取字符串中满足正则表达式的所有的子串，返回一个列表
注意：如果正在表达式中有分组，取值的时候只取分组中匹配到的结果;
如果有多个分组，会将每个分组匹配到的结果作为一个元祖的元素

re_str = r'(\d+)k([a-d]+)'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.findall(re_str, str1)
print(result)  # [('8923', 'abc'), ('890', 'aa')]

re_str = r'(\d+)k[a-d]+'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.findall(re_str, str1)
print(result)  # ['8923', '890']

re_str = r'\d+k[a-d]+'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.findall(re_str, str1)
print(result)  # ['8923kabc', '890kaa']

f.finditer
finditer(正则表达式，字符串)
查找所有满足正则条件的子串，返回值是迭代器，迭代器中的元素是匹配对象

re_str = r'\d+'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.finditer(re_str, str1)
print(result) # 
for item in result:
    print(item)
<_sre.SRE_Match object; span=(3, 5), match='34'>
<_sre.SRE_Match object; span=(9, 13), match='8923'>
<_sre.SRE_Match object; span=(20, 21), match='9'>
<_sre.SRE_Match object; span=(25, 28), match='890'>

g.split
split(正则表达式，字符串)
将字符串按照满足正则表达式条件的子串进行分割

str1 = 'ahsb1sssa8-jjhd7nhs+90nsjhf3-4hhh7+8kjj-'
result = re.split(r'[-+]', str1)
print(result) # ['ahsb1sssa8', 'jjhd7nhs', '90nsjhf3', '4hhh7', '8kjj', '']

h.sub
sub(正则表达式，repl，字符串)
将字符串中满足正则表达式条件的子串替换成repl。返回替换后的字符串

str1 = 'hsj8jskfh98ssjj8hshh'
result = re.sub(r'\d+', '*', str1)
print(result) # hsj*jskfh*ssjj*hshh

str1 = '智      障,你在干嘛？逼, 后视镜，妈的加扣扣上'
result = re.sub(r'傻\s*叉|逼|fuck|妈的|智\s*障', '*', str1)
print(result) # *,你在干嘛？*, 后视镜，*加扣扣上