01-正则表达式

正则表达式就是检测字符串是否满足某种规则的工具
例如：账号是手机号/邮箱/多少位由什么东西组成的ect
1.正则语法
2.2.Python对正则表达式的支持，提供了一个内置模块：re
fullmatch(正则表达式，字符串）：判断字符串是否符合正则表达式的规则

• 匹配任意字符
  匹配一个字符串，只有一个字符并且是任意字符

re_str = r'.'
result = fullmatch(re_str,'a')
print(result)

匹配一个字符串，有两个任意字符

re_str = r'..'
result = fullmatch(re_str,'an')
print(result)

匹配一个字符串，前三位分别是abc，最后一位是任意字符

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

• \w匹配字母数字下划线
  匹配一个前三分别是abc，最后一位是字母数字，下划线其中的一种的字符串

re_str = r'abc\w'
result = fullmatch(re_str,'abc_')
print(result)

• \W匹配非字母数字下划线
  匹配一个前三分别是abc，最后一位非字母数字，下划线的字符串

re_str = r'abc\W'
result = fullmatch(re_str,'abc_')
print(result)

• \s匹配空白字符（空白指空格、回车、制表符等所有你能产生空白的字符）
  匹配一个字符串，前三个是字母数字下划线中的任意一种，最后一位是一个空白字符

re_str = r'\w\w\w\s'
result = fullmatch(re_str,'a1_\t')
print(result)

• \S匹配非空白字符（空白指空格、回车、制表符等所有你能产生空白的字符）
  匹配一个字符串，前三个是字母数字下划线中的任意一种，最后一位非空白字符

re_str = r'\w\w\w\S'
result = fullmatch(re_str,'a1_9')
print(result)

• \d匹配一个数字字符
  匹配一个字符串，前三位是数字字符，最后一位是任意字符

re_str = r'\d\d\d.'
result = fullmatch(re_str,'151h')
print(result)

• \D匹配一个非数字字符
  匹配一个字符串，前三位是非数字字符，最后一位是任意字符

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

• \b检测是否是单词边界（单词的开头 ，单词的结尾、单词和单词之间的标点，空格ect
  注意：正则中遇到\b，匹配的时候先不管他，匹配成功后再回头看\b的位置是不是边界。
  匹配一个字符串，前四位是when第五位是空白，空白后边是where，并且第四位n后面是单词边界

re_str = r'when\b\swhere'
result = fullmatch(re_str,'when where')
print(result)

• ^检测字符串是否是以给定的正则表达式,匹配字符串的开头

re_str = r'\d\d\d.'
result = fullmatch(re_str,'151h')
print(result)
re_str = r'^m\d\d'
result = fullmatch(re_str,'m14')
print(result)

• $检测字符串是否以给定的正则表达式结束
  匹配一个字符串a数字，并且a数字是字符串的结尾

re_str = r'a\d$'
result = fullmatch(re_str,'a2')
print(result)

result = search(re_str,'a9aaa8')
print(result)

• \B检测非单词边界

re_str = r'any\Bwhere'
result = fullmatch(re_str,'anywhere')
print(result)

• []匹配中括号出现的任意字符
  注意：一个中括号只匹配一个字符
  匹配一个三位的字符串，第一位是a或者b或者或者+，后面两位是数字

re_str = r'[abc+]\d\d'
result = fullmatch(re_str,'+12')
print(result)

• -在正则表达式中的中括号中的应用：如果将减号放到两个字符的中间代表的是谁到谁。如果想要表示'-'符号本身，就放到开头或者末尾
  [1-8]代表的是：12345678
  [-18]或者[18-]代表的是'1','-','8'
  要求一个字符串中的第一位是1-8中的一个，后面两位是小写字母

re_str = r'[1-8][a-z][a-z]'
result = fullmatch(re_str,'1bg')
print(result)

re_str = r'[+!-][A-Z]'
result = fullmatch(re_str,'+A',)
result = fullmatch(re_str,'-B',)
result = fullmatch(re_str,'!C',)
print(result)

• [^字符集]匹配不在[]字符集中的任意一个字符
  匹配一个四位的字符串，第一位不是大写字母也不是数字，后三位是abc

re_str = r'[^A-Z\d]abc'
result = fullmatch(re_str,'+abc')
print(result)

• • 匹配0次或者多次

re_str = r'a*b'   # 'b','ab','aab',.....以此类推
result = fullmatch(re_str,'aaaaaaaaaaab')
re_str = r'\d*'
re_str = r'[abc]*'   # 'a','abbccbaababa',''
print(result)

• • 匹配一次或者多次，与* 类似
    判断一个字符串是否是无符号的正整数

re_str = r'[1-9]+\d*'
result = fullmatch(re_str,'110')
print(result)

• ？ 匹配0次或者一次

re_str = r'@?\d+'
result = fullmatch(re_str,'@16723')
print(result)

• 判断一个字符串是否是整数

re_str = r'[+-]?[0-9]\d*'
result = fullmatch(re_str,'0')
print(result)

• {N}匹配N次,就只有N位字符

re_str = r'\d{3}'
result = fullmatch(re_str,'123')
print(result)

• {N,} 至少匹配N次

re_str = r'\w{3,}'
result = fullmatch(re_str,'1234sda__')
print(result)

• {,N} 最多匹配N次

re_str = r'a{,2}b'
result = fullmatch(re_str,'b')
result = fullmatch(re_str,'ab')
result = fullmatch(re_str,'aab')
result = fullmatch(re_str,'aaab')
print(result)

• {M,N} 匹配至少M次，最多N次（M<N）

re_str = r'a{1,2}b'
result = fullmatch(re_str,'ab')
print(result)

注意：次数相关的操作，都是约束的次数符号前的一个字符

• | 分支（相当于逻辑运算中的or）
  匹配一个字符串是三个字母，或者是三个数字

re_str = r'[A-Za-z]{3}|\d{3}'
re_str1 = r'\d{3}[A-Za-z]{3}|\d{3}'
# \d{3}[A-Za-z]当做分支的一个整体的条件，|分支的左边部分是一个整体，右边是一个整体
result = fullmatch(re_str,'abg')
print(result)

正则中分支有短路操作：如果使用|去连接多个条件，前面的条件已经符合，就不会使用后面的条件再去匹配了

练习：写一个正则表达式，能够匹配出字符串中所有的数字（包括整数和小数）

# re_str = r'[1-9]\d*[.]?\d*|0[.]\d+'
# result = fullmatch(re_str,'0.12')
# print(result)
str1 = 'absx12.2ss2.03s40,60aas50,asd6.23,952asd'
re_str = r'[\d.]+'
# '\d+[.]\d+' 与'[1-9]\d*'的位置不同，输出的结果也有可能不一样
result = findall(re_str,str1)
print('======================')
print(result)

• 分组
  通过加（）来对正则条件进行分组
  两位数字两位字母出现三次

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

• 重复
  可以通过\数字来重复匹配前面的括号中匹配的结果.数字的值代表前面的第几个分组

re_str = r'(\d{2}[A-Z])=%\1\1'
result = fullmatch(re_str,'23B=%23B23B')
print(result)
re_str = r'(\d{2})\+(\w)\1{2}\2'
result = fullmatch(re_str,'12+a1212a')
print('++++++++++++++++++++')
print(result)

• 捕获
  按照完整的正则表达式去匹配，只捕获（）中的内容，只有在findall中有效

re_str = r'a(\d{3})b'
result = fullmatch(re_str,'a786b')
print(result)
print(findall(re_str,'a786b'))

# 用户名由字母数字下划线组成的6-20位
user= input('用户名：')
QQ = input('qq:')
re_str = r'\w{6,20}'
result = fullmatch(re_str,user)
if result == None:
    print('用户名不合格，请重新输入')
else:
    print('用户名：%s 合格'% user)

# QQ由数字组成并且第一位不能是0
re_str = r'[1,9]+\d{4,11}'
result = fullmatch(re_str,QQ)
if result == None:
    print('用户名不合格，请重新输入')
else:
    print('用户名：%s 合格'% QQ)

02-正则中的转义

1.正则表达式中的转义和字符串中的转义字符没有任何关系，
在Python中的字符串前加r阻止的是字符串的转义，不能阻止正则表达式的转义
2.在正则表达式中，可以通过在特殊意义的符号前加\来表示符号本身
+ . * ? \ ( ) [ ] ^ $ |
注意：
a. - 号只有在中括号中的两个字符之间才有特殊的意义
b.如果特殊符号放到[]中，作为字符集的内容，那么除了- 号在两个字符之间以外，其他的都不需要转义
c.\ 不管在哪都需要转义，^放到 中括号的最前需要转义

re_str = r'a\+}'
result = fullmatch(re_str,'a\+')
print(result)

re_str = r'\+a'
result = fullmatch(re_str,'+a')
print(result)

re_str = r'\\w-a'
result = fullmatch(re_str,'\w-a')
print(result)

re_str = r'\(\d{3}'
result = fullmatch(re_str,'(234')
print(result)

re模块

1.compile(正则表达式)：将正则表达式转换成正则表达式对象

re_str = r'\d+'
re_object = re.compile(re_str)
print(re_object)

# 不转成对象，调用相应的函数
re.match(re_str,'78hj')
# 转换成对象，调用相应的方法
re_object.fullmatch('78hj')

2.match(正则表达式，字符串)和fullmatch
判断字符串的开头是否能够和正则表达式匹配
fullmatch：判断整个字符串是否能够和正则表达式匹配

re_str = r'abc\d{3}'
result1 = re.match(re_str,'abc234dafdad')
result2 = re.fullmatch(re_str,'abc234')
print(result1)
print(result2)

# a.匹配范围,匹配结果字符的下标范围:（起始下标，结束下标）---- 结束下标取不到
print(result2.span())
# 获取起点
print(result1.start())
# 获取终点
print(result1.end())

注意：group参数，用来指定分组对应的相应的结果

re_str = r'(\d{3})\+([A-z]{3})'
match1 = re.match(re_str,'123+abcgg')
print(match1)
print(match1.span())
# 在匹配中，获取第一个分组的范围
print(match1.span(1))
# 在匹配中，获取第二个分组的范围
print(match1.span(2))

# 在匹配结果中，获取第二个分组的起始下标
print(match1.start(2))

# b.获取匹配结果对应的字符串
print(match1.group())
print(match1.group(1))

# c.获取被匹配的原字符串
print(match1.string)

• search（正则表达式，字符串）
  在字符串中去查找第一个满足正则表达式的子串，如果找到就返回匹配对象，找不到返回None

search1 = re.search(r'\d+aa','he9aasda 78aadvsf world')
print(search1)
if search1:
    print(search1.span())

练习：使用search将一个字符串所有的数字字符串全部找到
’工资10000元，年龄18岁，身高180，颜值100‘

str1 = '工资10000元，年龄18岁，身高180，颜值100'
re_str = r'[1-9]\d*'
search1 = re.search(re_str,str1)
while search1:
    print(search1.group())
    end = search1.end()
    str1 = str1[end:]
    search1 = re.search(re_str,str1)

• split（正则表达式，字符串）
  按满足正则表达式的子串去切割字符串

str1 = '床前明月光，疑是地上霜。举头望明月，低头思故乡！'
result = re.split(r'[,。，！]',str1)
result = re.split(r'\W',str1)
print(result)

中文也在\w的范围内

• sub（正则表达式，替换字符串，被替换的字符串）

word = '你丫是傻叉吗？我草拟大爷的，Fuck you'
result2 = re.sub(r'傻叉|草|大爷|Fuck|傻逼','*',word)
print(result2)

• findall（正则表达式，字符串）

# 获取字符串中所有满足正则表达式的子串
# 返回值是列表
# 注意：分组中的捕获效果在这儿有效
result = re.findall(r'\d([a-z])+','数据的恐怖残5and,125name按贷款')
# 取的字符串是正则表达式最后一个字符
result1 = re.findall(r'\d([a-z]+)','数据的恐怖残5and,125name按贷款')
# 取的字符串是正则表达式中的后一个分组
print(result)
print(result1)