2021-5-18正则表达式和面向对象

正则表达式和面向对象

检查类型符号

from re import fullmatch,findall

# 1. \b   -   检测是否是单词边界
"""
单词边界: 凡是可以将两个单词区分开的符号都是单词边界,
        比如：空白字符、标点符号对应的字符、字符串开头和结尾

注意：检测类符号是在匹配成功的情况下看检测类符号所在的位置是否符合要求
"""
re_str = r'abc\b 123'
print(fullmatch(re_str,'abc 123'))

re_str = r'\b\d\d\b'
result = findall(re_str,'shj23都是45的所得税67,的撒,89.的撒旦撒爱上')
print(result)           # ['89']

# 2. \B - 检测是否不是单词边界
re_str = r'\B\d\d\B'
result = findall(re_str,'shj23都是45的所得税67,的撒,89.的撒旦撒爱上')
print(result)           # ['23', '45']

# 3.^ - 检测是否是字符串开头
re_str = r'^\d\d'
result = findall(re_str,'99shj23都是45的所得税67,的撒,89.的撒旦撒爱上')
print(result)           # ['99']
re_str = r'^\D\D'
result = findall(re_str,'shj23都是45的所得税67,的撒,89.的撒旦撒爱上')
print(result)           # ['sh']

# 4. $ - 检查是否是字符串结尾
re_str = r'\d\d$'
result = findall(re_str,'99shj23都是45的所得税67,的撒,89.的撒旦撒爱上88')
print(result)           # ['88']

匹配次数

from re import fullmatch,match
"""
三个a:'aaa'   == 'a{3}'
三个数字:'\d\d\d'   ==  '\d{3}'
2到5个大写字母： '[A-Z]{2,5}'
"""
# 1. *  -   0次或者多次(任意次数)
"""
a*  ->  a出现0次或多次
\d* ->  \d出现0次或多次 -> 任意数字出现0次或多次
[abc]* -> [abc]出现0次或多次 -> 每次a b c 任意出现0次或多次
"""
re_str = r'a\d*b'
print(fullmatch(re_str,'ab'))
print(fullmatch(re_str,'a4b'))
print(fullmatch(re_str,'a456789b'))

# 2. +  ->  1次或多次
re_str = r'a+b'
print(fullmatch(re_str,'aab'))
print(fullmatch(re_str,'ab'))
print(fullmatch(re_str,'a4b'))         # None
print(fullmatch(re_str,'a456789b'))    # None

# 3. ?  ->  0次或1次
re_str = r'[-+]?[1-9]\d'
print(fullmatch(re_str,'22'))
print(fullmatch(re_str,'-33'))
print(fullmatch(re_str,'+44'))
print(fullmatch(re_str,'01'))      # None

# 4. {}
"""
{N}       -  匹配N次
1[3-9]\d{9}

{M,N}     -  匹配M到N次
1[3-9]\d{1,3}

{M,}      -  匹配至少M次

{,N}      -  匹配最多N次

"""
re_str = r'1a{2,5}2'
print(fullmatch(re_str,'1aaaaa2'))
re_str = r'1a{,5}2'
print(fullmatch(re_str,'12'))
re_str = r'1a{2,}2'
print(fullmatch(re_str,'1aaaaaaaaaa2'))

# 5. 贪婪和非贪婪
"""
在匹配次数不确定的时候才有贪婪和非贪婪两种模式.
贪婪:在能匹配成功的前提下取匹配次数最多的次数. (默认)
非贪婪:在能匹配成功的前提下去匹配次数最少的次数.(在匹配次数后加?)
"""
re_str = r'a.+?b'
print(fullmatch(re_str,'a福鼎市666b的撒b'))
print(match(re_str,'asdasbhhhhb123b大声道'))

分组和分支

from re import fullmatch
# 1. 分组  -  ()
"""
用法1:将正则表达式中的一部分作为一个整体,进行整体相关操作,比如控制次数
用法2:重复-使用\M来重复前面第M个分组中的内容
用法3:捕获
"""
# 'amn23abm45mnh78'
re_str = r'([a-z]{3}\d{2}){3}'
print(fullmatch(re_str,'amn23abm45mnh78'))

# '22.33.56.54'
re_str = r'(\d{2}\.){3}\d{2}'
print(fullmatch(re_str,'22.33.56.54'))

# '34abc34'    '78abc78'
re_str = r'(\d{2})abc\1'
print(fullmatch(re_str,'78abc78'))

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

re_str = r'(\d{2})=\1=([\u4e00-\u9fa5])=\2=([A-Z])=\3'
print(fullmatch(re_str,'22=22=狗=狗=A=A'))

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

# 3.转义符号
# 在本身具备特殊功能或者特殊意义的符号前加\,让其功能或者意义消失,表示一个普通符号
re_str = r'\d{2}\.\d{2}'
print(fullmatch(re_str,'12.34'))

# 注意:独立具备特殊功能的符号在[]中功能会自动消失,例如: +  *  ?  .  (     )  等
# 本身在[]中有特殊意义的就要特别注意: ^   -   [      ]

re模块

import re
from re import *
# 1. compile(正则表达式)  -  创建一个正则表达式对象
re_obj = compile(r'\d{3}')

print(re_obj.fullmatch('123'))

print(fullmatch(r'\d{3}', '321'))

# 2. 匹配类方法
"""
1)fullmatch
fullmatch(正则表达式,字符串)
正则表达式对象.fullmathc(字符串)
判断整个字符串是否符合正则表达式描述的规则,如果不符合返回None,符合返回匹配对象.

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

"""
result = match(r'(\d{3})-([a-z]{2,5})','789-dhm撒旦法还是觉得非控股撒旦教弗兰克')
print(result)
# 1) 匹配对象.group()   -   获取整个正则表达式匹配到的结果
print(result.group())       # '789-dhm'
print(result.group(1))      # '789'
print(result.group(2))      # 'dhm'

# 2) 获取匹配结果在原字符中的位置
# 匹配对象.span()
# 匹配对象.span(N)
print(result.span())        # [0,7)
print(result.span(2))       # [4,7)

# 3) 获取原字符串
# 匹配对象.string
print(result.string)

# 3.查找类方法
"""
search(正则表达式,字符串)
正则表达式对象.search(字符串)  ->  获取字符串中第一个满足正则表达式的子串,如果没有返回None,否则返回匹配对象
"""
result = search(r'\d{3}','adss123321数据sad--dsaasd的撒是999')
print(result)       # <re.Match object; span=(4, 7), match='123'>

"""
findall(正则表达式,字符串)
正则表达式对象.findall(字符串)   -  获取字符串中所有满足正则表达式的子串,以列表的形式返回,列表中的元素是字符串
"""
str1 = 'sd12ds23=-21dsa87对双方都21,90m76'
result = findall(r'\d+',str1)
print(result)   # ['12', '23', '21', '87', '21', '90', '76']
result = findall(r'[\u4e00-\u9fa5]\d+',str1)
print(result)   # ['都21']
# 如果正则中有分组,findall只提取匹配结果中分组匹配到的内容
result = findall(r'[\u4e00-\u9fa5](\d+)',str1)
print(result)   # ['21']
result = findall(r'([\u4e00-\u9fa5])(\d+)',str1)
print(result)   # [('都', '21')]

"""
finditer(正则表达式,字符串)
正则表达式对象.finditer(字符串)   -   获取字符串中所有满足正则表达式的子串,返回值是迭代器,迭代器中的元素是匹配对象
"""
str1 = 'shk32水垫都21341=-37ml889撒的撒3,90m7788'
result = finditer(r'\d+',str1)
print(list(result))
"""
[<re.Match object; span=(3, 5), match='32'>, 
<re.Match object; span=(8, 13), match='21341'>, 
<re.Match object; span=(15, 17), match='37'>, 
<re.Match object; span=(19, 22), match='889'>,
 <re.Match object; span=(25, 26), match='3'>, 
 <re.Match object; span=(27, 29), match='90'>, 
 <re.Match object; span=(30, 34), match='7788'>]
"""


result = finditer(r'(\d+)','hshs889-mn三生三世枕上书2-mkl==-892-ma=计算机')
print('整个正则匹配结果:',[x.group() for x in result])      # 整个正则匹配结果: ['889-mn', '2-mkl', '892-ma']
print(result)
result = finditer(r'(\d+)-([a-z]+)','hshs889-mn三生三世枕上书2-mkl==-892-ma=计算机')
print('分组1的匹配结果:',[x.group(1) for x in result])     # 分组1的匹配结果: ['889', '2', '892']

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

split(正则表达式,字符串,最大切割数)
"""
str1 = '的撒的撒78浮点数9豆腐豆腐8发的的算法9990fsdj放电视剧3-==鸡肉卷'
result = split(r'\d+',str1)
print(result)

str2 = '失敬失敬,上岛咖啡好.是的放假时间,世界上的解放后.是就是就是'
result = split(r'[,.]',str2)
print(result)

result = split(r'[,.]]',str2,2)
print(result)

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

"""
result = sub(r'\d+','+','素数7素数88jsj2929sj失敬失敬0-=')
print(result)       # 素数+素数+jsj+sj失敬失敬+-=

result = sub(r'\d','+','素数7素数88jsj2929sj失敬失敬0-=')
print(result)       # 素数+素数++jsj++++sj失敬失敬+-=

result = sub(r'傻[(bB逼]|f\s*u\s*c\s*k','*','你个傻逼fuck')
print(result)        # 你个**

匹配参数

from re import *

# 匹配参数: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'))

# 2.忽略大小写
"""
默认不忽略大小写.
忽略大小写的时候,大小字母可以和对应的小写字母匹配,小写字母也可以和对应的大写字母匹配
"""
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'>