# day 16正则

day 16正则

1.二进制数据的转换

1.1二进制类型/字节(bytes)
1.2其他数据转二进制：bytes(数据)

字符串转二进制：字符串.encode(encoding= 'utf-8')
print(bytes(10))    # b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
print(bytes(True))  # b'\x00'
print(bytes(12.5))      # TypeError: cannot convert 'float' object to bytes
print(bytes('abc', encoding='utf-8'))   # b'abc'
print(bytes([1, 2, 3]))         # b'\x01\x02\x03'

list1 = [100, 'abc', 12.5]
b1 = bytes(str(list1), encoding='utf-8')
print(b1)

str2 = 'hello'
b2 = str2.encode(encoding='utf-8')

1.3二进制转字符串：str(数据, encoding=‘utf-8’)

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

# 方法二：二进制数据.decode(encoding='utf-8')
str2 = b2.decode(encoding='utf-8')
print(str2)

2.正则语法

from re import fullmatch, search, findall, S, I

import re

2.1什么是正则表达式

正则表达式是一种工具：一种专门用作字符串匹配的工具，能够在某些情况下让字符串的处理变得非常简单。
正则是用来描述字符串规则

检测符号

fullmatch(正则表达式, 字符串) - 判断正则表达式是否和字符串完全匹配，如果不匹配返回None

正则表达式的语法（通用）
1）普通字符
普通字符在正则表达式中表示这个符号本身

# 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, 'mbc')
print(result)   # <re.Match object; span=(0, 3), match='mbc'>

# 3) \d - 匹配任意一个数字字符
re_str = r'\d\d\d'
result = fullmatch(re_str, '144')
print(result)       # <re.Match object; span=(0, 3), match='144'>

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

# 4) \D     -   匹配任意一个非数字字符（正则中大写和小写的功能是相反的）
re_str = r'\d\D\d'
result = fullmatch(re_str, '8我0')
print(result)   # <re.Match object; span=(0, 3), match='8我0'>

# 5）\s  -   匹配任意一个空白字符
# 空白字符：空格、\n(换行)、\t(制表符)
re_str = r'abc\s123'
print(fullmatch(re_str, 'abc 123'))

# 6) \S -   匹配任意一个非空白字符
re_str = r'abc\S\d'
print(fullmatch(re_str, 'abcn3'))       # <re.Match object; span=(0, 5), match='abcn3'>

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

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

注意：一个[]只能匹配一个字符

[abc] - 匹配一个字符是a或者b或者c
[\dabc] - 匹配一个字符是数字或者a或者b或者c
[1-9] - 匹配1到9的任意一个数字字符, -在[]中两个字符之间才有特殊意义
[2-5abc] - 匹配2到5中任意一个数字字符或者a或者b或者c
[a-z] - 匹配任意一个小写字母
[a-zA-Z] - 匹配任意一个字母
[\da-zA-Z_] - 匹配字母、数字、下划线
[\u4e00-\u9fa5] - 匹配任意一个中文字符

name = 123
re_str = rf'[{name}]123'
print(fullmatch(re_str, '1123'))    # <re.Match object; span=(0, 4), match='1123'>

re_str = r'[\dxy=]mn'
print(fullmatch(re_str, '5mn'))     # <re.Match object; span=(0, 3), match='5mn'>

# -在[]中两个字符之间才有特殊意义
re_str = r'[-abc]12-3'
print(fullmatch(re_str, '-12-3'))   # <re.Match object; span=(0, 5), match='-12-3'>

9. [^字符集] - 匹配不在字符集中的任意一个字符, ^ 只能放在最前面才有特殊功能
   [^abc] - 匹配除了abc以外的任意一个字符
   [^\dxy] - 匹配除了xy和数字以外的任意一个字符
   [^a-z] - 匹配除了小写字母以外的任意一个字符
   [^\u4e00-\u9fa5] - 匹配除了中文以外的任意一个字符
   注意：^在[]中，如果没有在开头就表示这个符号本身

print(fullmatch(r'[a^bc]123', 'a123'))
# 只要是^abc中的符号都能匹配

检测符号

匹配符号要求一个符号必须对应一个字符，会影响字符串长度的描述;
检测符号，不会匹配字符，也不会影响字符串长度，他是在匹配成功的前提下对指定位置的字符进行检测
1）\b - 检测是否是单词边界
单词边界 - 所有能够区分出两个不同单词的符号，例如：空白字符、标点符号、字符串开头和字符串结尾

re_str = r'abc\b\s123'
print(fullmatch(re_str, 'abc 123'), 2)

# 2) \B - 检测是否不是单词边界
re_str = r"abc\B123"
print(re.fullmatch(re_str, "abc123"), 1)

# 3) ^  - 检测是否是字符串开头
re_str = r"^123abc"
print(re.fullmatch(re_str, "123abc"), 2)


# 4)$   -   检测是否是字符串结尾
re_str = r'\d\d$'
print(search(re_str, 'asdfsdfsdfsdfasasdf打赏28'))    # <re.Match object; span=(21, 23), match='28'>

匹配次数

1. • • 0或多次
       a* - 字符a出现0次或者多次
       \d* - 任意数字出现0次或多次（实质是\d在正则中出现0次或多次）
       [字符集]* - 字符集中的任意字符出现0次或者多次（每次都可以是字符集中的任意一个）

re_str = r'\d'*10
print(fullmatch(re_str, '0123456789'))
re_str = r'\d*bc'
print(fullmatch(re_str, 'bc'))
print(fullmatch(re_str, '1bc'))
print(fullmatch(re_str, '123bc'))

# 2) +  -   1次或者多次（至少1次）
re_str = r'a[A-Z]+c'
print(fullmatch(re_str, 'ac'))  # None

# 3) ? - 0次或1次

# 写一个正则能匹配任意正整数： 23， 3490， +87， 023（None）
re_str = r'[+]?[1-9]\d*'
print(fullmatch(re_str, '023'))

# 4) {}
"""
{N} -   匹配N次
{M,N}  -   匹配M到N次
{M,}    -   匹配至少M次
{,N}    -   匹配最多N次
"""
re_str = r'\d{3}'
print(fullmatch(re_str, '298'))

# 用户名的要求：全部由数字或者字母组成，长度是3~6
re_str = r'[\da-zA-Z]{3,6}'
print(fullmatch(re_str, '2k98'))

print(fullmatch(r'a{3,}123', 'aaa123'))
print(fullmatch(r'a{,3}123', 'aaa123'))

# 5)贪婪和非贪婪
"""
在匹配次数不确定的时候匹配模式有两种：贪婪（默认）和非贪婪（在不确定次数后面加?）
（+、*、?、{M, N}、{M,}、{,N}）
贪婪：在能匹配成功的前提下，匹配次数选最多的
非贪婪：在能匹配成功的前提下，匹配次数选最少的（+?、*?、??、{M, N}?、{M,}?、{,N}?）
"""
# 贪婪模式：
re_str = r'a.+b'
print(search(re_str, 'xxamnbppbppb==='))        # <re.Match object; span=(2, 12), match='amnbppbppb'>

# 非贪婪模式：
re_str = r'a.+?b'
print(search(re_str, 'xxamnbppbppb==='))    # <re.Match object; span=(2, 6), match='amnb'>

分组

1）()

用法一：整体操作次数
(ab){2,3}
用法二：
\M - 重复前面第M个分组

用法三：捕获
re中的findall在获取子串的时候，如果正则中有分组，只会获取分组匹配到的结果

print(fullmatch(r'(ab){2,3}','ababab'))    # <re.Match object; span=(0, 6), match='ababab'>

# 两个数字两个字母的结构重复3~5次89nm78jk89mk
print(fullmatch(r'(\d{2}[a-z]{2}){3,5}', '89nm78jk89mk'))   # <re.Match object; span=(0, 12), match='89nm78jk89mk'>

re_str = r'(\d)\1(4)\1'
print(fullmatch(re_str, '8848'))

re_str = r'a\d{2}b'
print(findall(re_str, 'mmmma78bkkka98blasa-a01b==='))       # ['a78b', 'a98b', 'a01b']
re_str = r'a(\d{2})b'
print(findall(re_str, 'mmmma78bkkka98blasa-a01b==='))   # ['78', '98', '01']

分支

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_str = r'abc(\d{3}|[A-Z]{3})'
print(fullmatch(re_str, 'abcKNM'))

转义符号

在正则中有特殊意义的符号前加\，让这个符号在正则中的功能消失。

re_str = r'\d{2}\.\d{2}'
print(fullmatch(re_str, '15.34'))

# 注意：在正则中独立存在有特殊意义的符号，放到[]中，它的意义会自动消失

re_str = r'[ab\]cA\-D]123'
print(fullmatch(re_str, '-123'))
# 单行匹配
print(fullmatch(r'a.b', 'a\nb'))    # None
# 多行匹配
print(fullmatch(r'a.b', 'a\nb', flags=S))   # <re.Match object; span=(0, 3), match='a\nb'>

# 忽略大小写
print(fullmatch(r'abc', 'ABC', flags=I))
print(fullmatch(r'(?i)abc', 'ABC'))  # <re.Match object; span=(0, 3), match='ABC'>

# 忽略大小写并且单行匹配（i和s的位置前后没有关系）
print(fullmatch(r'abc', 'ABC', flags=I | S))
print(fullmatch(r'(?is)abc', 'ABC'))  # <re.Match object; span=(0, 3), match='ABC'>

3.re模块的使用

import re

3.1re.compile(正则表达式) - 编译正则表达式，返回正则对象

re_obj = re.compile(r'\d{3}')
# 正则表达式对象.fullmatch(字符串)
print(re_obj.fullmatch('888'))      # <re.Match object; span=(0, 3), match='888'>
# re.fullmatch(正则表达式, 字符串)
print(re.fullmatch(r'\d{3}', '889'))    # <re.Match object; span=(0, 3), match='889'>

3.2匹配
fullmatch(正则, 字符串) - 让整个字符串和正则进行匹配，匹配失败返回None，匹配成功返回匹配对象
match(正则, 字符串) - 让字符串的开头和正则进行匹配，匹配失败返回None，匹配成功返回匹配对象

print(re.match(r'\d{3}', '678jingdongfang1asd'))

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

result = re.match(r'(\d{2})([a-z]{3})([A-Z]{2})', '23asdASSDAS2')
print(result.group())       # 23asdAS
print(result.group(0))      # 23asdAS
print(result.group(1))      # 23
print(result.group(2))      # asd

2)匹配范围 - 匹配到的子串在原字符串中的下标范围
匹配对象.span()

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

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

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

# 没有分组 ['123', '343']
print(re.findall(r'\d{3}', 'asdasd123sdasdfgd343jaas=='))       # ['123', '343']
# 有一个分组 ['123']
print(re.findall(r'a(\d{3})', 'asdasda123sdasdfgd343jaas=='))       # ['123', '343']
# 有两个或者两个以上的分组：[('a', '123')]
print(re.findall(r'd(a)(\d{3})', 'asdasda123sdasdfgd343jaas=='))

print(re.findall(r'(\d|[a-z])[A-Z]{2}', 'hkM-水电费8MN速度快的6AZ'))

# 3)finditer
result = re.finditer(r'd(a)(\d{3})', 'asdasda123sdasdfgd343jaas==')
print(list(result), type(result))   # [<re.Match object; span=(5, 10), match='da123'>] <class 'callable_iterator'>

3.4

split(正则, 字符串) - 将字符串中满足正则的子串作为切割点
sub(正则, 字符串1, 字符串2) - 将字符串2中满足正则的子串全部替换成字符串1

result = re.split(r'\d+', 'asdasdas123asdasgdf54sdf546g')
print(result)       # ['asdasdas', 'asdasgdf', 'sdf', 'g']

result = re.sub(r'\d+', '+', 'asdasdas123asdasgdf54sdf546g')
print(result)       # asdasdas+asdasgdf+sdf+g