day16-正则表达式和面向对象

一、检测类符号

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

单词边界：凡是可以将两个单词分开的符号都是单词边界，比如：空白字符、标点符号对应的字符，字符串开头和结尾

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

re_str = r'abc \b123'
print(fullmatch(re_str, 'abc 123'))re_str = r'\b\d\d'
result = findall(re_str, '99shj23结合实际 45 计时开始67，数据，89.计算机90l 78')
print(result)   # ['45', '89', '78']

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

re_str = r'\B\d\d\B'
result = findall(re_str, '99shj23结合实际 45 计时开始67，数据，89.计算机90l 78')
print(result)   # ['23', '90']

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

re_str = r'^\d\d'
result = findall(re_str, '99shj23结合实际 45 计时开始67，数据，89.计算机90l 78')
print(result)   # ['99']

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

re_str = r'\d\d$'
result = findall(re_str, '99shj23结合实际 45 计时开始67，数据，89.计算机90l 78')
print(result)   # ['78']

二、匹配次数

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

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

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

1.* - 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, 'a4b'))
print(fullmatch(re_str, 'a67273872b'))

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

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

？ - 0次或1次

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

4.{}

{N} - 匹配N次

{M,N} - 匹配M到N次，M和N都可以取到

{M，} - 匹配至少M次

{，N} - 匹配最多N次

re_str = r'1a{2,5}2'
print(fullmatch(re_str, '1aa2'))
print(fullmatch(re_str, '1aaaaa2'))
print(fullmatch(re_str, '1a2'))      # None

5.贪婪和非贪婪

在匹配次数不确定的时候才有贪婪和非贪婪两种模式
贪婪：在能匹配成功的前提下取匹配次数最多次数。（默认）
非贪婪：在能匹配成功的前提下去匹配次数最少的次数。（在匹配次数后加？）

re_str = r'a.+b'
print(fullmatch(re_str, 'a发阿打算打打234b'))
print(match(re_str, 'asshbljlbddsb给及安达市多'))  # 3次  7次 11次  贪婪模式取11次
# <re.Match object; span=(0, 13), match='asshbljlbddsb'>re_str = r'a.+?b'
print(match(re_str, 'asshbljlbddsb给及安达市多'))  # 3次  7次 11次  非贪婪模式取3次
# <re.Match object; span=(0, 5), match='asshb'>

三、分组和分支

1.分组 - （）

用法1：将正则表达式中的一部分作为一个整体，进行整体相关操作，比如控制次数

用法2：重复-使用\M来重复前面第M个分组中的内容

用法3：捕获

re_str = r'([a-z]{3}\d{2}){3}'
print(fullmatch(re_str, 'asd34fas45fsa54'))# '22a34a44a41'
re_str = r'(\d{2}a){3}\d{2}'
print(fullmatch(re_str, '22a34a44a41'))# '34abc34'、'78abc78'
re_str = r'(\d\d)abc\1'
print(fullmatch(re_str, '12abc12'))
print(fullmatch(re_str, '12abc21'))   # Nonere_str = r'(\d{2})=([\u4e00-\u9fa5])=\2=\1'
print(fullmatch(re_str, '23=王=王=23'))re_str = r'(\d{2})=\1=([\u4e00-\u9fa5])=\2'
print(fullmatch(re_str, '23=23=王=王'))# re_str = r'(\d{2})=\2=([\u4e00-\u9fa5])=\2'
# print(fullmatch(re_str, '23=王=王=王'))   # 报错：

2.分支 - |

正则表达式1|正则表达式2 - 先让正则1和字符进行匹配，如果成功就成功，如果失败就和正则2进行匹配
如果正则2成功结果匹配成功，否则匹配失败（两个正则中只有一个可以匹配成功结果就成功否则失败

# '23abc'、'MKHabc'
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, '23abc'))

3.转义符号

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

re_str = r'[1-9]{2}\.\d{2}'
print(fullmatch(re_str, '19s23'))   # None
print(fullmatch(re_str, '19.23'))re_str = r'\d\+\d'
print(fullmatch(re_str, '2+9'))

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

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

re_str = r'\d[+]\d'
print(fullmatch(re_str, '2+9'))

四、re模块

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

re_obj = re.compile(r'\d{3}')
result = re_obj.fullmatch('123')
print(result)

2.匹配类方法

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

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

result = match(r'((\d{3})-)([a-z]{2,5})', '829-jjs爱仕达大所')
print(result)

1)获取匹配结果

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

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

print(result.group())   # ‘829-jjs’
print(result.group(1))  # '829-'
print(result.group(2))  # '829'
print(result.group(3))  # 'jjs'

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

匹配对象.span()

匹配对象.span(N)

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

3)获取原字符串

匹配对象.string

print(result.string)    # '829-jjs爱仕达大所'

3.查找类方法

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

result = search(r'\d{3}', 'shs23132睡觉觉980hsh-sjjha098')
print(result)

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

str1 = 'ss34垃圾袋443kad-232adsd423239'
result = findall(r'\d+', str1)
print(result)   # ['34', '443', '232', '423239']result = findall(r'[\u4e00-\u9fa5]\d+', str1)
print(result)   # ['袋443']

如果正则中有分组,findall只提取匹配结果中分组匹配到的内容

result = findall(r'[\u4e00-\u9fa5](\d+)', str1)
print(result)   # ['443']

如果正则中有多个分组,findall会将每个分组组成一个元组

str2 = '829-jjs爱仕达大所'
result = findall(r'((\d{3})-)([a-z]{2,5})', str2)
print(result)

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

str1 = 'ss34垃圾袋443-kad-232-adsd423239'
result = finditer(r'\d+', str1)
print(list(result))result = finditer(r'(\d+)-([a-z]+)', str1)
print('整个正则匹配结果：', [x.group() for x in result])  # 整个正则匹配结果： ['443-kad', '232-adsd']

4.切割

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

split(正则表达式，字符串,最大切割数）

str1 = '打开2爱斯达克34阿昆达89艾迪康00爱健康打卡88阿昆达'
result = split(r'\d+', str1)
print(result)  # ['打开', '爱斯达克', '阿昆达', '艾迪康', '爱健康打卡', '阿昆达']
str2 = '大家都撒，卡还是打开。阿萨德所，拉时间段里。卡时间段开'
result = split(r'[，。]', str2)
print(result)    # ['大家都撒', '卡还是打开', '阿萨德所', '拉时间段里', '卡时间段开']result = split(r'[，。]', str2, 3)
print(result)    # ['大家都撒', '卡还是打开', '阿萨德所', '拉时间段里。卡时间段开']

5.替换

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

result = sub(r'\d+', '+', 'asddas3ad90dada77aj1213')
print(result)   # asddas+ad+dada+aj+result = sub(r'\d+', '+', 'asddas3ad90dada77aj1213', 3)
print(result)  # asddas+ad+dada+aj1213

五、匹配参数

匹配参数：1.单行匹配、2.忽略大小写

1.单行匹配和多行匹配

默认是多行匹配。
多行匹配的时候.不能和\n（换行）匹配；单行匹配的时候，可以和\n匹配

print(fullmatch(r'a.b', 'a\nb'))  # None

单行匹配

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

2.忽略大小写

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

print(fullmatch(r'[a-zA-Z]{3}123', 'Hsm123'))
print(fullmatch(r'[a-z]{3}123', 'Hsm123'))  # None
print(fullmatch(r'[a-z]{3}123', 'Hsm123', flags=I))  # <re.Match object; span=(0, 6), match='Hsm123'>
print(fullmatch(r'(?i)[a-z]{3}123', 'Hsm123'))       # <re.Match object; span=(0, 6), match='Hsm123'>

单行匹配和忽略大小写同时进行

print(fullmatch(r'abc.123', 'ABC\n123', flags=I|S))  # <re.Match object; span=(0, 7), match='ABC\n123'>
print(fullmatch(r'(?is)abc.123', 'ABC\n123'))        # <re.Match object; span=(0, 7), match='ABC\n123'>

六、编程思想

面向过程编程（穷人思想） - 逻辑+算法

函数式编程（小资思想） - 函数

面向对象编程（富豪思想） - 类和对象

1.类和对象

什么是类：具有相同功能和相同属性的对象集合。 - 抽象的概念
什么是对象：对象就是类的实例