python100day- day16 - 正则表达式

from re import fullmatch, search, findall

一、正则语法

匹配符号

1.什么是正则表达式

""" 正则表达式是一种工具;一种专门用作字符串匹配的工具，能够在某些情况下让字符串的处理变得非常简单。 fullmatch(正则表达式, 字符串) - 判断正则表达式是否和字符串完全匹配， 如果不匹配返回None """

2.正则表达式的语法(通用的)

1）普通字符

""" 普通字符在正则表达式中表示这个符号本身 """ # 匹配一个字符串有三个字符，分别是a,b,c re_str = r'abc' result = fullmatch(re_str, 'abc') print(result) # <re.Match object; span=(0, 3), match='abc'>

2) . - 匹配任意一个字符

# 匹配一个长度是3的字符串，第一个字符是任意字符，后面是bc re_str = r'.bc' result = fullmatch(re_str, 'xbc') print(result) # <re.Match object; span=(0, 3), match='xbc'> re_str = r'a..c' result = fullmatch(re_str, 'axvc') print(result) # <re.Match object; span=(0, 4), match='axvc'>

3) \d - 匹配任意一个数字字符

re_str = r'\d\d\d' result = fullmatch(re_str, '111') print(result) # <re.Match object; span=(0, 3), match='111'> re_str = r'\d\dabc' result = fullmatch(re_str, '11abc') print(result) # <re.Match object; span=(0, 5), match='11abc'>

4) \D - 匹配任意一个非数字字符

re_str = r'\d\D\d' result = fullmatch(re_str, '1s2') print(result) # <re.Match object; span=(0, 3), match='1s2'>

5) \s - 匹配任意一个空白字符

空白字符:空格、换行\n、\t(制表符)

re_str = r'abc\s123' result = fullmatch(re_str, 'abc 123') print(result) # <re.Match object; span=(0, 7), match='abc 123'>

6） \S - 匹配任意一个非空白字符

re_str = r'abc\D\d' result = fullmatch(re_str, 'abcs8') print(result) # <re.Match object; span=(0, 5), match='abcs8'> re_str = r'\S...' print(fullmatch(re_str, 'nini')) # <re.Match object; span=(0, 4), match='nini'>

7) \w - 匹配任意一个数字、字符或者下划线（不好用，非ASCII码中的字符都可以匹配）

8）[字符集] - 匹配字符集中出现的任意一个字符

""" 注意:一个[]只能匹配一个字符 [abc] - 匹配一个字符是a或者b或者c [\dabc] - 匹配一个字符是数字或者 a 或者 b 或者 c [1-9] - 匹配一个字符是数字1~9中的任意一个 [a-z] - 匹配任意一个小写字母 [a-zA-Z] - 匹配任意一个字母 [\da-zA-Z_] - 匹配字母数字下划线 [\u4e00-\u9fa5] - 匹配任意一个中文字符 """ re_str = r'[abc]123' result = fullmatch(re_str, 'b123') print(result) # <re.Match object; span=(0, 4), match='b123'> re_str = r'[\dxy=]mn' result = fullmatch(re_str, '=mn') print(result) # <re.Match object; span=(0, 3), match='=mn'>

注意： - 减号在[]中两个字符之间才有特殊意义

re_str = r'[-abc]12-3' result = fullmatch(re_str, '-12-3') print(result) # <re.Match object; span=(0, 5), match='-12-3'>

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

""" [^abc] - 匹配除了abc以外的任意一个字符 [^\dxy] - 匹配除了数字和xy以外的任意一个字符 [^a-z] - 匹配除了小写字母以外的任意一个字符 [^\u4e00-\u9fa5] - 匹配除了中文以外的任意一个字符 """ print(fullmatch(r'[^abc]123', 'a123')) # None print(fullmatch(r'[\u4e00-\u9fa5]123', '好123')) # <re.Match object; span=(0, 4), match='好123'>

检测符号

匹配符号要求一个符号必须对应一个字符，会影响字符串长度的描述；

检测符号，不会匹配字符，也不会影响字符串长度，它是在匹配成功的前提下对指定位置的字符进行检测

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

""" 单词边界 - 所有能够区分出两个不同单词的符号，例如:空白字符、标点符号、字符串开头和字符串结尾 """ re_str = r'abc\b\s123' result = fullmatch(re_str, 'abc 123') print(result) # <re.Match object; span=(0, 7), match='abc 123'>

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

re_str = r'abc\B123' print(fullmatch(re_str, 'abc123')) # <re.Match object; span=(0, 6), match='abc123'>

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

re_str = r'abc^123' print(fullmatch(re_str, 'abc123')) # None re_str = r'^abc123' print(fullmatch(re_str, 'abc123')) # <re.Match object; span=(0, 6), match='abc123'>

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

re_str = r'\d\d$' print(fullmatch(re_str, 'ddvjidv那几率22ss33')) print(search(re_str, 'dfsafsSdasf333是送给备份11'))

匹配次数

1）* - 0次或多次

""" a* - 字符a出现0次或者多次 \d* - 任意数字出现0次或多次（实质是\d在正则中出现0次或多次） [字符集]* - 字符集中的任意字符出现0次或者多次（每次都可以是任意一个） """ re_str = r'a*bc' print(fullmatch(re_str, 'aaaaaaaaaaaaaaaabc')) # <re.Match object; span=(0, 18), match='aaaaaaaaaaaaaaaabc'> re_str = r'a\d*c' print(fullmatch(re_str, 'a247675325675c')) # <re.Match object; span=(0, 14), match='a247675325675c'> re_str = r'a[A-Z]*c' print(fullmatch(re_str, 'aDc')) # <re.Match object; span=(0, 3), match='aDc'>

2) + - 一次或多次（至少一次）

re_str = r'a[A-Z]+c' print(fullmatch(re_str, 'ac')) # None

3）？ - 0次或1次

写一个正则能匹配任意正整数：23, 3434, +87, 023(None)

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

4){}

""" {N} - 匹配N次 {M,N} - 匹配M到N次 {M,} - 匹配至少M次 {,N} - 匹配到最多N次 """ re_str = r'\d{3}' print(fullmatch(re_str, '212')) # 用户名的要求：全部由数字或者字母组成，长度是3~6位 re_str = r'[\da-zA-Z]{3,6}' print(fullmatch(re_str, '123eee')) print(fullmatch(r'a{3,}123', 'aaa123')) # <re.Match object; span=(0, 6), match='aaa123'> print(fullmatch(r'a{,3}123', 'aa123')) # <re.Match object; span=(0, 5), match='aa123'>

5)贪婪和非贪婪

""" 在匹配次数不确定的时候，匹配模式有两种：贪婪(默认)和非贪婪(再不确定后面加?号) 贪婪：在能匹配成功的前提下，匹配次数选最多的(+,*,?,{M,N},{M,},{,N}) 非贪婪：在能匹配成功的前提下，匹配次数选最少的(+?, *?, ??, {M,N}?, {M,}?, {,N}?) """

贪婪模式：

re_str = r'a.+b' print(search(re_str, 'xxasdbsdfebfdd==可发放符合b---')) # <re.Match object; span=(2, 22), match='asdbsdfebfdd==可发放符合b'>

非贪婪模式：

re_str = r'a.+?b' print(search(re_str, 'xxasdbsdfebfdd==可发放符合b---')) # <re.Match object; span=(2, 6), match='asdb'>

分组

1）()

""" 用法一：整体操作 a{2,3} (ab){2,3} 用法二:重复 \M - 重复前面第M个分组中匹配到的内容 用法三：捕获 re中的findall在获取子串的时候，如果正则中有分组，只会获取分组匹配到的结果 """

两个数字两个字母的结构重复3到5次，类似：89nm78dd89hh

re_str = r'(\d{2}[a-z]{2}){3,5}' print(fullmatch(re_str, '23dl45jk12jk45gh32fg')) re_str = r'(\d)\1abc\1' print(fullmatch(re_str, '22abc2')) re_str = r'M(\d[a-z])N\1([A-Z])\2' print(fullmatch(re_str, 'M4aN4aQQ')) re_str = r'a\d{2}b' print(findall(re_str, 'mma78bghga67bhgha34bbh')) # ['a78b', 'a67b', 'a34b'] re_str = r'a(\d{2})b' print(findall(re_str, 'mma78bghga67bhgha34bbh')) # ['78', '67', '34']

分支

1) |

""" 正则1|正则2|正则3|.... 先用正则1进行匹配，如果匹配成功整个正则就匹配成功；如果匹配失败就用正则2进行匹配， 如果成功整个正则就匹配成功，如果失败就用正则3进行匹配，以此类推... """

写一个正则能够匹配一个字符串:abc后面是三个数字或者abc后面是三个大写字母

re_str = r'abc\d{3}|abc[A-Z]{3}' print(fullmatch(re_str, 'abc123')) # <re.Match object; span=(0, 6), match='abc123'> print(fullmatch(re_str, 'abcAAA')) # <re.Match object; span=(0, 6), match='abcAAA'> re_str = r'abc(\d{3}|[A-Z]{3})' print(fullmatch(re_str, 'abc233')) # <re.Match object; span=(0, 6), match='abc233'> print(fullmatch(re_str, 'abcFSV')) # <re.Match object; span=(0, 6), match='abcFSV'>

转义符号

""" 在在正则中有特殊意义的符号前加\, 让这个符号在正则中的功能消失。 """ re_str = r'\d{2}\.\d{2}' print(fullmatch(re_str, '34.24')) # <re.Match object; span=(0, 5), match='34.24'> # 注意:在正则中独立存在有特殊意义的符号，放到[]中，它的意义会自动消失 re_str = r'[.+*]abc' print(fullmatch(re_str, '.abc'))

二、re模块的使用

import re

1.compile(‘正则表达式’) - 编译正则表达式，返回正则对象

re_obj = re.compile(r'\d{3}')

正则表达式对象.fullmatch(字符串)

print(re_obj.fullmatch('789'))

re.fullmatch(正则表达式, 字符串)

print(re.fullmatch(r'\d{3}', '789'))

2.匹配

""" fullmatch(正则, 字符串) - 让整个字符串和正则进行匹配，匹配失败返回None，匹配成功返回匹配对象 match(正则, 字符串) - 让字符串开头和正则匹配，匹配失败返回None，匹配成功返回匹配对象 """ print(re.match(r'\d{3}', '345hvfyfyfyf个is过户后古尔沟')) # <re.Match object; span=(0, 3), match='345'>

3.匹配对象

result = re.match(r'(\d{2})([a-z]{3})([A-Z]{2})', '23aasSAssff') print(result)

1)匹配到的字符串

匹配对象.group() / 匹配对象.group(0) - 获取整个正则匹配到的子串

匹配对象.group(N) - 获取第N个分组匹配到的子串

print(result.group(0)) # 23aasSA print(result.group(1)) # 23 print(result.group(3)) # SA

2）获取匹配范围 - 匹配到的子串在原字符串中的下标范围

匹配对象.span()

print(result.span()) # [0, 7] print(result.span(2)) # (2, 5)

4.查找

""" search(正则, 字符串) - 在字符串中查找第一个满足正则的子串，如果找到了返回匹配对象，找不到返回None findall(正则, 字符串) - 获取字符串中所有满足正则的子串，返回值是列表，列表中的元素是字符串或者元组 finditer(正则, 字符串) - 获取字符串中所有满足正则的子串，返回值是迭代器，迭代器中的元素是匹配对象 """

1)search

print(re.search(r'\d{3}', 'hfhfgs245hfuh登记表吃饭饭费'))

2)findall

# 没有分组 print(re.findall(r'\d{3}', '355udjgugb124jnjdbf766ggh')) # ['355', '124', '766'] # 有一个分组 print(re.findall(r'a(\d{3})', 'a234kgnrknha664mkhkna323gff')) # ['234', '664', '323'] # 有两个或者两个以上的分组 print(re.findall(r'([a-z]{2})(\d{3})', 'abm678十几年a092sdjb8239==-a786lksa119Kjd')) # [('bm', '678'), ('jb', '823'), ('sa', '119')] print(re.findall(r'(\d|[a-z])[A-Z]{2}', 'hKM-水电费8MN速度快的9PP')) # ['h', '8', '9']

3）finditer

result = re.finditer(r'([a-z]{2})(\d{3})', 'abm678十几年a092sdjb8239==-a786lksa119Kjd') print(result) # <callable_iterator object at 0x00000267ABB8F048> print(list(result)) # [<re.Match object; span=(1, 6), match='bm678'>, <re.Match object; span=(15, 20), match='jb823'>, <re.Match object; span=(30, 35), match='sa119'>]

5.切割和替换

""" split(正则, 字符串) - 将字符串中满足正则的子串作为切割点 sub(正则,字符串1, 字符串2) - 将字符串2中满足正则的子串全部替换成字符串1 """ result = re.split(r'\d+', 'asjj823kasjkdfh299jSDK飞机和478sdjfh3上课的家伙5上看到回复') print(result) # ['asjj', 'kasjkdfh', 'jSDK飞机和', 'sdjfh', '上课的家伙', '上看到回复'] result = re.sub(r'\d+', '+', 'asjj823kasjkdfh299jSDK飞机和478sdjfh3上课的家伙5上看到回复') print(result) # asjj+kasjkdfh+jSDK飞机和+sdjfh+上课的家伙+上看到回复

二进制数据的转换

1.二进制类型/字节(bytes)

2.其他数据转二进制:bytes(数据)

print(bytes(10)) # b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' # print(bytes(12.5)) 报错！ print(bytes(True)) # b'\x00' print(bytes('abc', encoding='utf-8')) # b'abc' print(bytes([1, 2])) # b'\x01\x02' # print(bytes(['abc', '123'])) 报错！ list1 = [100, 'abc', 12.5] b1 = bytes(str(list1),encoding='utf-8') print(b1) # b"[100, 'abc', 12.5]"

3.二进制转字符串:

方法一：str(数据)

字符串转二进制:字符串.encode(encoding=‘utf-8’)

str1 = str(b1, encoding='utf-8') print(str1) # [100, 'abc', 12.5] list1 = eval(str1) print(list1,type(list1)) # [100, 'abc', 12.5] <class 'list'> str2 = 'hello' b2 = str2.encode(encoding='utf-8') print(b2) # b'hello'

方法二:二进制数据.decode(encoding=‘utf-8’)

str2 = b2.decode(encoding='utf-8') print(str2) # hello