2.22学习总结

五异常捕获和正则表达式

一、异常捕获

# 1.什么是异常：程序运行报错
# 后果：在异常的地方结束，不会往后继续执行

# 2.异常捕获：当程序出现异常的时候，不崩溃，继续执行后面的代码
# 什么时候需要捕获：明知道某个地方会发生异常，但是代码没有问题（是用户的不当操作导致的）
"""
语法1：    捕获所有类型的异常
try:
    代码1
except:
    代码2

说明：try，except都是关键字
代码1————需要捕获异常代码
代码2————出现异常后，会执行的代码
执行过程：先执行try里的代码，没有异常，直接执行其他代码（不会执行代码段2）
如果代码1出现异常，则马上执行except后的代码2

语法2：    某一种异常
try:
    代码1
except 指定异常类型:
    代码2

语法3：    同时捕获多种异常，但是异常之后都会执行代码2
try：
    代码1
except(异常1，异常2。。。。)：
    代码2

语法4：    与语法三基本相同，只是针对不同异常，代码执行的不一样
try:
    代码1
except 异常1：
    代码11
except 异常2：
    代码22
except 异常3：
    代码33
。。。
"""
# try:
#     age = int(input('请输入年龄：'))
# except:
#     print('年龄输入有误')
#     age = 0
# print(f'年龄是：{age}')
# print('++++++++++')
#
# # 练习：打开指定的文本文件，如果文件存在就读文件中的内容，如果不存在就创建这个文件。
# try:
#     with open('./123.txt', 'r', encoding='utf-8')as f:
#         f.read()
# except:
#     print('文件不存在')
#     with open('./123.txt', 'w', encoding='utf-8')as f:
#         f.write('xxx')

# 3.关键字finally
# finally的存在不影响原来异常捕获的执行
# finally后面的代码不管try里面的代码发生什么情况，都会执行。（就算出现异常，没有被捕获，也会执行）

二、正则匹配符号

from re import fullmatch
# 1.什么是正则表达式：让复杂的字符串处理变得更加简单的工具

# 2.正则语法
# fullmatch(正则表达式, 字符串) -   判断字符串是否满足正则表达式描述的规则，如果不满足返回None
# python中正则表达式是写到单引号或者双引号里面

# 1) 普通字符：指的是除了特殊符号以外的都是普通字符，普通字符在正则表达式中表示符号本身
re_str = 'dsa'
result = fullmatch(re_str, 'dsa')
print(result)

# 2)    .   --匹配一个任意字符
re_str2 = 'a.c'
# 规则：一个字符串有三个字符，第一个a,第三个c，中间任意字符(几个.就代表几个任意字符)
result2 = fullmatch(re_str2, 'a胡c')
print(result2)

# 3) \d     --  匹配一个任意数字
re_str3 = r'a\d\da'     # r的作用是防止字符转义
# 规则：一个字符串有四个字符，第一个和最后一个a，中间两个任意数字
result3 = fullmatch(re_str3, 'a12a')
print(result3)

# 4) \s     --匹配一个任意空白字符
# 空白字符：空格、\n、\t
re_str4 = r'\d\d\s\d\d'
# 规则：一个字符串开头两个数字，结尾两个数字，中间一个空白
result4 = fullmatch(re_str4, '45 56')
print(result4)

# 5) \D     --匹配任意一个非数字字符
# 规则：一个字符串有四个字符，第一个不是数字，后面是abc
re_str5 = r'\Dabc'
result5 = fullmatch(re_str5, '=abc')
print(result5)

# 6) \S     --匹配任意一个非空白字符
re_str6 = r'\d\Ddsa'
# 规则：一个字符有5个，第一个任意数字，第二个不是空白，后面dsa
result6 = fullmatch(re_str6, '8=dsa')
print(result6)

# 7) [字符集] --匹配字符集中任意一个字符
"""
注意：一个[]只能匹配一个字符
    -如果在两个字符之间，表示范围，前面编码值小于后面编码值
    -如果不在两个字符之间，就表示-本身
[abc你]  -- 能匹配a或者b或者c，或者‘你’
[abc\d] --  能匹配a或者b或者c，或者任意一个数字
’a[23456]b‘ --  a和b之间有2到6的任意一个数字
’a[2-6]b‘ --  a和b之间有2到6的任意一个数字
[a-zA-Z]    --  匹配任意一个字母
[A-Z\d]     --  匹配一个任意大写字母或者任意一个数字
[\u4e00-\u9fa5] --  匹配任意一个中文
"""
re_str7 = r'[\dA-Za-z_]123'
result7 = fullmatch(re_str7, '_123')
print(result7)

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

三、正则检测类的符号

from re import fullmatch, search
# 匹配类的符号：普通字符 . \d \s \D \S [字符集] [^字符集]
# 检测类的符号：检测符号所在位置是否符合符号要求(注意：检测类的符号不影响匹配)
# 1. \b --  检测是否是单词边界（所有可以划分出两个不同单词的符号，空白，标点符号，字符串开头或者结尾）
re_str1 = r'abc\b,123'
result1 = fullmatch(re_str1, 'abc,123')
print(result1)              # <re.Match object; span=(0, 7), match='abc,123'>

# 2. \B     --检测是否是非单词边界
re_str2 = r'a.\Bb'
result2 = fullmatch(re_str2, 'apb')
print(result2)              # <re.Match object; span=(0, 3), match='apb'>

# 3. ^      --  检测是否是单词开头
re_str3 = r'^\d\d\d'
result3 = fullmatch(re_str3, '456')
print(result3)              # <re.Match object; span=(0, 3), match='456'>

re_str3 = r'^\d\d\d'
result3 = search(re_str3, 'dsah456as45x')
print(result3)          # None

re_str3 = r'\d\d\d'
result3 = search(re_str3, 'dsah456as45x')
print(result3)              # <re.Match object; span=(4, 7), match='456'>

# 4. $      --检测是否是字符串结尾
re_str4 = r'\d\d\d$'
result4 = search(re_str4, 'dsah456as45x')
print(result4)              # None

四、匹配次数

from re import fullmatch, search
# 1. *      --匹配0次或者多次
# a*    --匹配任意多个字符a
# \d*   --匹配任意多个数字字符
re_str1 = r'a\d*b'       # ab之间可以有多个数字,也可以没有
result1 = fullmatch(re_str1, 'ab')
print(result1)

# 2. +  --匹配一次或者多次
re_str2 = r'a\d+b'       # ab之间可以有多个数字,也可以没有
result2 = fullmatch(re_str2, 'a12123b')
print(result2)           # <re.Match object; span=(0, 7), match='a12123b'>

# 3. ?  --匹配0次或者1次
re_str3 = r'-?\d\d'
result3 = fullmatch(re_str3, '-23')
print(result3)          # <re.Match object; span=(0, 3), match='-23'>

# 练习
re_str4 = r'[-+]?\d+'
result4 = fullmatch(re_str4, '0')
print(result4)

# 4.{}
"""
{N}     --匹配N次
{M,N}   --匹配M到N次
{M,}    --匹配至少M次
{,N}    --匹配最多N次
"""
re_str4 = r'\d{5}'
result4 = fullmatch(re_str4, '45612')
print(result4)

re_str4 = r'a\d{2,5}b'
result4 = fullmatch(re_str4, 'a456b')
print(result4)          # <re.Match object; span=(0, 5), match='a456b'>

# 5.贪婪和非贪婪：只有在匹配次数不确定的时候，才有这两个模式
# 贪婪：在能匹配成功的前提之下，取最多的次数（默认情况下都是最长的那个）
# 非贪婪：在能匹配成功的前提之下，取最少的次数
# 在匹配次数不定的次数后加？，就会变成非贪婪模式
re_str5 = r'a.+b'
result5 = fullmatch(re_str5, 'a4561b3后端b')
print(result5)          # match='a4561b3后端b'> (贪婪)

re_str5 = r'a.+?b'
result5 = search(re_str5, 'a4561b3后端b')
print(result5)          # match='a4561b'> (非贪婪)

五、分支和分组

from re import fullmatch, search, findall
# 1.分组  --用（）将正则的一部分括起来看成一个整体进行操作
# 用法一：
re_str1 = r'(\d{2}[a-z]{3}){3}'
print(fullmatch(re_str1, '45fda78dsa55xzc'))

# 用法二：整体重复
# 在包含分组的正则中，可以通过\N来重复前面第N个分组匹配到的内容
re_str1 = r'a(\d{2})\1'
print(fullmatch(re_str1, 'a4545'))  # match='a4545'>

# 用法三：捕获（只针对findall有效）
re_str = r'tel:(\d{5})'     # 将对应的tel中的分组内容单独取出（如果没有括号，则tel也会显示）
print(findall(re_str, 'tel:23768, name:xiaoming, age:18岁，id:27237486; tel:72891, name:张三, age:67岁, id:23479782'))

# 2.分支  --  |
# r'正则表达式1|正则表达式2'  --先1进行匹配，如果失败，用2匹配。如果都失败，整体失败
# dsa45,dsaJKL
re_str1 = r'dsa(\d{3}|[A-Z]{3})'
print(fullmatch(re_str1, 'dsa456'))     # match='dsa456'>
print(fullmatch(re_str1, 'dsaBNM'))     # match='dsaBNM'>

六、转义符号

from re import fullmatch
# 正则的转义符号：在具有特殊功能或者特殊意义的符号前加\，让原来的功能和热意义消失，表示符号本身
re_str = r'dsa\.'
print(fullmatch(re_str, 'dsa.'))

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

# 具有特殊意义和功能的独立的符号，放在[]里面，功能自动消失，列如：+，?，$ ,^(不放在最前面)，|等
re_str = r'dsa[.+?$^()]'
print(fullmatch(re_str, 'dsa)'))