day16_正则表达式和面向对象-CSDN博客

本文链接：https://blog.csdn.net/niki__/article/details/117003413

day16_正则表达式和面向对象

回顾
新知识
作业
- - 利用正则表达式完成下面的操作:
  - - 一、不定项选择题
    - 二、编程题

回顾

json数据格式
1）有且仅有一个数据
2）这个数据必须是json支持的类型的数据
数字 — 直接写
字符串 — 双引号
布尔 — true false
空值 — null
数组 — [元素1,元素2……]
字典 — {键1：值1……}，键必须是字符串

python和json的相互转换

import json
json.loads(json格式的字符串)
json.dumps(python数据)

异常捕获

try:
    需要捕获异常的代码
except:
    捕获到异常会执行代码

try:
    需要捕获异常的代码
except(异常类型名1，异常类型名2):
    捕获到异常会执行代码

try:
    需要捕获异常的代码
except 异常类型名:
    捕获到异常会执行代码

try:
    需要捕获异常的代码
except 异常类型1:
    捕获到异常会执行代码
except 异常类型2:
    捕获到异常会执行代码

抛出异常

raise 异常类型

class AgeError(Exception):
    def __str__(self):
        return '错误描述'

正则语法

匹配类型符号

普通字符

.

\d、\D 数字

\s、\S 空白符

[字符集]

[0+p;]

[abc\d]

[1-5A-Z]

[字符集]、[^字符集]

新知识

1. 检测类符号

1). \b – 检测是否是单词边界

单词边界：凡是可以把两个单词分开的符号都是单词边界（空白字符，标点符号,字符串开头和结尾

注意：检测类符号是在匹配成功的情况下看检测类符号所在位置是否符合要求

from re import fullmatch,findall

re_str = r'abc \b123'   #re_str = r'abc\b123'-----None
print(fullmatch(re_str,'abc 123'))
re_str = r'\d\d'
result = findall(re_str,'ssd21knk12,fdknk234')
print(result)
re_str = r'\d\d\b'
result = findall(re_str,'ssd21knk12,fdknk234')
print(result)

2). \B – 检测是否不是单词边界

re_str = r'\B\d\d\B'
result = findall(re_str,'23,efgd12,sfd23dfsf')
print(result)

3). ^ – 检测是否是字符串开头

^ 只有放在字符串开头才有价值

re_str=r'^asd'
print(findall(re_str,'aaddfvfdghg')) #[]
print(findall(re_str,'asddfvfdghg'))  #asd

re_str=r'^\d\d'
print(findall(re_str,'12324dfvf.133dghg'))
#['12']

4). $ – 检测是否是字符串结尾

re_str = r'^\d\d$'
print(findall(re_str,'1321')) #[]
re_str = r'\d\d$'
print(findall(re_str,'1321')) #['21']

2. 匹配次数

1). 多个相同字符串

三个a:‘aaa’ == ‘a{3}’

三个数字:’\d\d\d’ == ‘\d{3}’

2到5个大写字母: ‘[A-Z]{2,5}’

2）. * --0次或者多次（任意次数）

a* — a出现0次或多次

\d* ---- \d出现0次或多次，每次的一个\d可以是任意一个数字

[abc]* - [abc]出现0次或多次，每次的[abc]都可以在a、b、c中任意选一个

re_str = r'a\d*b'
print(fullmatch(re_str,'ab'))
print(fullmatch(re_str,'a3b'))
print(fullmatch(re_str,'a2345b'))

3）. + - 1次或多次（至少一次

re_str = r'a\d+b'
print(fullmatch(re_str,'ab'))  #None
print(fullmatch(re_str,'a4b'))
print(fullmatch(re_str,'asda23b'))

4). ? - 0次或1次

re_str = r'[+-]?[1-9]\d'
print(fullmatch(re_str,'16'))

5). {}

{N} — 匹配N次

{M,N} — 匹配M到N次，M和N都能取到

{M,} ---- 匹配至少M次

re_str = r'1a{2,5}2'
print(fullmatch(re_str,'1aaaa2'))
re_str = r'1a{3}2'
print(fullmatch(re_str,'1aaa2'))
# <re.Match object; span=(0, 6), match='1aaaa2'>
#<re.Match object; span=(0, 5), match='1aaa2'>

6). 贪婪和非贪婪

在匹配次数不确定的时候才有贪婪和非贪婪两种模式

贪婪：在能匹配成功的前提下，取匹配次数最多次数(默认)

非贪婪:在能匹配成功的前提下，取匹配次数最少的次数(在匹配次数后加?)

re_str = r'a.+b'
print(fullmatch(re_str,'asdbfdsf243b'))
print(match(re_str,'adsfbdgfffsdfbdsdbg'))
re_str = r'a.+?b'
print(match(re_str,'adsfbdgfffsdfbdsdbg'))
#<re.Match object; span=(0, 12), match='asdbfdsf243b'>
#<re.Match object; span=(0, 18), match='adsfbdgfffsdfbdsdb'>
#<re.Match object; span=(0, 5), match='adsfb'>

3. 分组和分支

1) 分组 -()

用法1：将正则表达式中的一部分作为一个整体，进行整体相关操作，比如控制次数
用法2：重复-使用\M来重复前面第M个分组中的内容

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

re_str = r'(\d\d)abc\1'
print(fullmatch(re_str,'12abc12')) # match
print(fullmatch(re_str,'12abc21')) # None

re_str = r'(\d{2})=([\u4e00-\u9fa5])=\2=\1'
print(fullmatch(re_str,'12=一=一=12'))

\x的分组，写的位置必须存在，比如\2不能写在第二个分组的前面

2). 分支

正则表达式1|正则表达式2 - 先让正则1和字符进行匹配，如果成功就成功，如果失败就和正则2进行匹配
只要有一个匹配成功就成功

‘23abc’、‘MKabc’

re_str = r'\d{2}abc|[A-Z]{3}abc'
print(fullmatch(re_str,'23abc'))
re_str = r'(\d{2}|[A-Z]{3})abc'
print(fullmatch(re_str,'ABCabc'))

3). 转义符号

在本身具备特殊功能桌子特殊意义的符号加\，让其功能或者意义消失，表示一个普通符号

re_str = r'[1-9]\d\.\d{2}'
print(fullmatch(re_str,'12.32'))
print(fullmatch(re_str,'23s32'))

re_str = r'\d\+\d'
print(fullmatch(re_str,'3+2'))

注意：独立具备特殊功能的符号，在[]中功能会自动消失，例如:+、*、？、.

re_str = r'\d[.]\d'
print(fullmatch(re_str,'2.3'))

本身在[]中有特殊意义的就要特别注意:^、[、]、+、-

re_str = r'\d[.^]\d'
print(fullmatch(re_str,'6^1'))

re_str = r'\d[\^]\d'
print(fullmatch(re_str,'6^2'))
#<re.Match object; span=(0, 3), match='6^1'>
#<re.Match object; span=(0, 3), match='6^2'>

4. re模块

1）.compile(正则表达式) - 创建一个正则表达式对象

re_obj = re.compile(r'\d{3}')
print(re_obj.fullmatch('234'))
print(re.fullmatch(r'\d{3}', '233'))

2).匹配类方法

a）fullmatch

fullmatch(正则表达式，字符串)
正则表达式对象.fullmatch(字符串) - 判断整个字符串是否符合正则表达式描述的规则，如果不符合返回None,符合返回匹配对象。

b) match

match(正则表达式，字符串)

正则表达式对象.match(字符串) - 判断字符开头是否符合正则表达式描述的规则，如果不符合返回None，符合返回匹配对象。

Ⅰ)匹配对象.group()

匹配对象.group()/匹配对象.group(0)- 获取整个正则表达式匹配到的结果

匹配对象.group(N) - 获取正则表达式中第N个分组匹配到的结果

print(result.group())
result = re.match(r'(\d{3})-([a-z]{2,5})', '234-dsf,2123-svsdg')
print(result.group(1))

第几次遇到的括号就是第几个分组，遇到嵌套也一样

result = re.match(r'((\d{3})-)([a-z]{2,5})', '234-dsf,2123-svsdg')
print(result.group(1))

Ⅱ)获取匹配结果在原字符中的位置

print(result.span())  #[0,7)
print(result.span(3)) #[4,7]

Ⅲ)获取原字符串

# 匹配对象.string
print(result.string)  #234-dsf,2123-svsdg

3) 查找类方法

a) search(正则表达式,字符串)

正则表达式.search(字符串) - 获取字符串中第一个满足正则表达式的子串，如果没有返回None,如果有返回匹配对象

result = re.search(r'\d{3}', '123e4asdsfa24343dsfsdv23q423')
print(result)
#<re.Match object; span=(0, 3), match='123'>

b)findall(正则表达式,字符串)

正则表达式对象.findall(字符串) - 获取字符串中所有满足正则表达式的字串，以列表的形式返回。列表中的元素是字符串(通常)

str1 = 'sffd21323=-=-=-=12321sdfsd,,.ff223'
result = re.findall(r'\d+',str1)
print(result)
#['21323', '12', '321', '223']

str1 = 'sff中午21323=-=-=-=12哦321sdfsd,,.ff223'
result =re.findall(r'[\u4e00-\u9fa5](\d+)',str1)
print(result)
# 如果findall里有分组，就只提取匹配结果中分组里的内容
#['21323', '321']

result = re.findall(r'\d+-[a-z]+','sf423--gvfdv2-df234-sfdsdf')
print(result)
#['2-df', '234-sfdsdf']
result = re.findall(r'(\d+)-([a-z]+)','sf423--gvfdv2-df234-sfdsdf')
print(result)
#[('2', 'df'), ('234', 'sfdsdf')]----元组

c)finditer(正则表达式,字符串)

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

str1 = '214dfs23sd.21/,.,sadsa21'
result = re.finditer(r'\d+', str1)
print(list(result))
#[<re.Match object; span=(0, 3), match='214'>, <re.Match object; span=(6, 8), match='23'>, <re.Match object; span=(11, 13), match='21'>, <re.Match object; span=(22, 24), match='21'>]

str1 = '214dfs23sd.21/,.,sadsa21'
result = re.finditer(r'\d+', str1)
# print(list(result))
print([x.group() for x in result])
['214', '23', '21', '21']

4). 切割

splite(正则表达式,字符串)
正则表达式对象.splite(字符串) - 将字符串中所有满足正则表达式的子串作为切割点对字符串进行切割

str1 = '房顶上23的防辐射344Jhkj就是的咖啡能看见233=的vd'
result = re.split(r'\d+', str1)
print(result)
result = re.split(r'\d+',str1,2)
print(result)
str2 = '徐爱国地，梵蒂冈。红泥小火炉，绿蚁新醅酒。'
result = re.split(r'[，。]',str2)
print(result)
#['房顶上', '的防辐射', 'Jhkj就是的咖啡能看见', '=的vd']
['房顶上', '的防辐射', 'Jhkj就是的咖啡能看见233=的vd']
#['徐爱国地', '梵蒂冈', '红泥小火炉', '绿蚁新醅酒', '']

5)替换

sub(正则表达式，字符串1,字符串2)
正则表达式对象.sub(字符串1,字符串2) - 将字符串2中所有满足正则表达式的子串都替换成字符串1

result = re.sub(r'\d+','+','sfsd21g说的过分23符合条件423543-=')
print(result)
result = re.sub(r'\d+','+','sfsd21g说的过分23符合条件423543-=',2)
print(result)
#sfsd+g说的过分+符合条件+-=
#sfsd+g说的过分+符合条件423543-=

6)匹配参数

单行匹配，忽略大小写

a)单行匹配和多行匹配

默认是多行匹配。

多行匹配的时候，不能和\n匹配

单行匹配的时候，可以和\n匹配

#多行匹配
print(fullmatch(r'a.b','a\nb')) #None
#单行匹配
#S是从re模块导入的
print(fullmatch(r'a.b','a\nb',flags=S))
print(fullmatch(r'(?s)a.b','a\nb'))
#None
#<re.Match object; span=(0, 3), match='a\nb'>
#<re.Match object; span=(0, 3), match='a\nb'>

b). 忽略大小写

默认不忽略大小写
忽略大小写的时候，大写字母可以和对应的小写字母匹配，小写字母也可以和大写字母匹配

print(fullmatch(r'[a-z]{3}123','hSs123'))#None

# 忽略大小写
print(fullmatch(r'(?i)[a-z]{3}123','hSs123'))
print(fullmatch(r'[a-z]{3}123','hSs123',flags=I))
#None
#<re.Match object; span=(0, 6), match='hSs123'>
#<re.Match object; span=(0, 6), match='hSs123'>

#单行匹配和忽略大小写同时进行
print(fullmatch(r'abc.123','ABC\n123',flags=I|S))
print(fullmatch(r'(?si)abc.123','ABC\n123'))

作业

利用正则表达式完成下面的操作:

一、不定项选择题

能够完全匹配字符串"(010)-62661617"和字符串"01062661617"的正则表达式包括（ A ,D）

A.r"$?\d{3}$?-?\d{8}"
B. r"[0-9()-]+"
C.r"[0-9(-)]*\d*"
D.r"[(]?\d*[)-]*\d*"

能够完全匹配字符串“back”和“back-end”的正则表达式包括（ A,B,C,D ）
A. r“\w{4}-\w{3}|\w{4}”
B. r“\w{4}|\w{4}-\w{3}”
C.r “\S±\S+|\S+”
D. r“\w*\b-\b\w*|\w*”
能够完全匹配字符串“go go”和“kitty kitty”，但不能完全匹配“go kitty”的正则表达式包括（A,C,D）
A.r “\b(\w+)\b\s+\1\b”
B. r“\w{2,5}\s*\1”
C. r“(\S+) \s+\1”
D. r“(\S{2,5})\s{1,}\1”
能够在字符串中匹配“aab”，而不能匹配“aaab”和“aaaab”的正则表达式包括（B, C）
A. r“a*?b”
B. r“a{,2}b”
C. r“aa??b”
D. r“aaa??b”

二、编程题

1.用户名匹配

要求: 1.用户名只能包含数字字母下划线

2.不能以数字开头

3.⻓度在 6 到 16 位范围内

name_strain = r'^\D[\w]{5,15}'
print(fullmatch(name_strain,'12_________'))

密码匹配

要求: 1.不能包含!@#¥%^&*这些特殊符号

2.必须以字母开头

3.⻓度在 6 到 12 位范围内

password_strain = r'[a-zA-Z][^!@#¥%^&*]{5,11}'
print(fullmatch(password_strain,'_aaaaa'))

ipv4 格式的 ip 地址匹配
提示: IP地址的范围是 0.0.0.0 - 255.255.255.255

ip = '278.253.10.4'
ip_find = r'\b\d+\b'
x = findall(ip_find, ip)
flag = ['A', 0]
if len(x) == 4:
    if not (fullmatch(r'((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}([0-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])', ip)):
        flag[1] = 1
    elif fullmatch(r'\b(\d|[1-9]\d|1[01]\d|12[0-7])\b', x[0]):
        flag[0] = 'A'
    elif fullmatch(r'\b([1]2[89]|1[3-8]\d|19[0-1])\b', x[0]):
        flag[0] = 'B'
    elif fullmatch(r'\b(19[2-9]|2[01]\d|22[0-3])\b', x[0]):
        flag[0] = 'C'
    elif fullmatch(r'\b(22[4-9]|23\d)\b', x[0]):
        flag[0] = 'D'
    elif fullmatch(r'\b(24[0-7])\b', x[0]):
        flag[0] = 'E'
else:
    flag[1] = 1

if flag[1] == 0:
    print(flag[0], '类地址', sep='')
else:
    print('ip有误')

提取用户输入数据中的数值 (数值包括正负数还包括整数和小数在内) 并求和

例如:“-3.14good87nice19bye” =====> -3.14 + 87 + 19 = 102.86

str1 = '-3.14good87nice19bye'
num_find = r'[\-\+]?\d+[\.]?\d+'
num_list = findall(num_find, str1)
sum1 = reduce(lambda x, y: x + float(y), num_list, 0)
print(float(num_list[0]), end='')
[print('+', float(x), end='', sep='') for x in num_list[1:]]
print('=', sum1)

验证输入内容只能是汉字

str1 = input('请输入汉字:')
str_find = r'[\u4e00-\u9fa5]{1,}'
str_tmp = fullmatch(str_find, str1)
if str_tmp:
    print('内容符合')
else:
    print('只能输入汉字')

匹配整数或者小数（包括正数和负数）

num_find = r'[\-\+]?\d+[\.]?\d+'
num_first = input('请输入数字:')
num_match = fullmatch(num_find,num_first)
if num_match:
    print('内容符合')
else:
    print('只能输入整数或小数')

验证输入用户名和QQ号是否有效并给出对应的提示信息

要求：
用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
QQ号是5~12的数字且首位不能为0

QQ_name = input('请输入QQ名字')
QQ_num = input('请输入QQ号')
name_match = fullmatch(r'[\w]{6,20}',QQ_name)
num_match = fullmatch(r'[1-9]\d{4,11}',QQ_num)
if name_match and num_match :
    print('successful！')
else:
    print('error!')

拆分长字符串：将一首诗的中的每一句话分别取出来

poem = ‘窗前明月光，疑是地上霜。举头望明月，低头思故乡。’

poem = '红泥小火炉，绿蚁新醅酒。晚来天欲雪，能饮一杯无？'
poem_tmp = split(r'[,，.。？?；;]',poem)
[print(x) for x in poem_tmp]