Day16-正则表达式

Day16-正则表达式

01-二进制数据的转换

1.二进制类型/字节（bytes）

2.其他数据转换二进制：bytes（数据）

1. 字符串转二进制：字符串.encode(encoding = 'utf-8')

   print(bytes(10))
   # print(bytes(12.5))
   print(bytes(True))
   # print(bytes('abc'))    # TypeError: string argument without an encoding
   print(bytes('abc', encoding='utf-8'))
   print(bytes([1, 2]))
   # print(bytes(['123',12]))
   
   list1 = [100, 'abc', 12.5]
   b1 = bytes(str(list1), encoding='utf-8')
   print(b1)
   

3.二进制转字符串

# 方法一:str(数据, encoding = 'utf-8')
str1 = str(b1, encoding='utf-8')
print(str1)
list1 = eval(str1)
print(list1)

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

02-正则语法

1.什么是正则表达式

正则表达式是一种工具；一种专门做字符串匹配的工具，能狗在某些情况下让字符串的处理变得非常简单。

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

2.正则表达式的语法

1.匹配字符

以下是部分的字符

1. 普通字符

   普通字符在正则表达式中表达这个符号本身

   re_str = r'abc'
   result = fullmatch(re_str, 'abc')
   print(result)
   

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

   re_str = r'.bc'
   result = fullmatch(re_str, '%bc')
   print(result)
   

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

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

5. \s - 匹配任意一个空白字符（空格、\n、\t）

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

7. \w - 匹配任意一个数字、字母或者下划线（不推荐用）

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

   """
   注意一个中括号只能匹配一个字符
   
   [abc]   -   匹配一个字符是a或者b或者c
   [\dabc] -   匹配一个字符是数字或者a或者b或者c
   
   [1-9]   -   匹配一到九的任意一个数字字符
   [a-z]   -   匹配任意一个小写字母
   [a-zA-Z] -  匹配任意一个字母
   [\da-zA-Z_]     -   匹配字母、数字、下划线
   [\u4e00-\u9fa5]     -   匹配任意一个中文字符
   """
   re_str = r'[\dxy=]mn'
   print(fullmatch(re_str, '9mn'))
   
   re_str = r'[0-9]{3}'
   print(fullmatch(re_str, '123'))
   
   re_str = r'[A-Za-z]'
   print(fullmatch(re_str, 'A'))
   
   # -在[]中两个字符之间才有特殊意义
   re_str = r'[-abc]12-3'
   print(fullmatch(re_str, '-12-3'))
   

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

   """
   [^abc]  -   匹配除了abc以外的任意一个字符
   """
   
   print(fullmatch(r'[^abc]123', 'q123'))
   print(fullmatch(r'[\u4e00-\u9fa5]123', '淦123'))
   

2.检测字符

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

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

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

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

3.匹配次数

1. * - 0次或多次

2. + - 1次或者多次（至少一次）

3. ? - 0次或一次

4. {}

   """
   {N}     -   匹配N次
   {M,N}   -   匹配M到N次
   {M,}    -   匹配至少M次
   {,N}    -   匹配最多N次
   """
   

5. 贪婪和非贪婪

   """
   在匹配次数不确定的时候匹配模式有两种：贪婪(默认)和非贪婪(再不确定后面加？)
   
   贪婪：在能匹配成功的前提下，匹配次数选最多的(+、*、?、{M,N}、{M,}、{,N})
   非贪婪：在能匹配成功的前提下，匹配次数选最少的(+?、*?、??、{M,N}?、{M,}?、{,N}?)
   """
   # 贪婪模式
   re_str = r'a.+b'
   print(search(re_str, 'xxamnbpppbsdb===='))
   # 非贪婪模式：
   re_str = r'a.+?b'
   print(search(re_str, 'xxamnbpppbsdb===='))
   
   
   re_str = r'a??b'
   print(search(re_str, 'abab'))
   

4.分组

1. ()

   """
   用法一：整体操作次数
   a{2,4}
   (ab){2,3}
   
   用法二：重复
   \M  -   重复前面第M个分组中匹配到的内容
   
   用法三：捕获
   re中的findall在获取子串的时候，如果在正则中有分组，只会获取分组匹配到的结果
   """
   # 两个数字两个字母的结构重复3到5次,类似:89nm78jk89mk
   re_str = r'(\d{2}[a-z]{2}){3,5}'
   print(fullmatch(re_str, '12df12df12gs34ds'))
   
   re_str = r'(\d)\1abc\1'
   print(fullmatch(re_str, '88abc8'))
   
   re_str = r'm(\d[a-z])n\1'
   print(fullmatch(re_str, 'm8an8a'))
   
   re_str = r'a\d{2}b'
   print(search(re_str, 'a89b'))
   print(findall(re_str, 'a98ba89b'))
   
   re_str = r'a(\d{2})b'
   print(search(re_str, 'a89b'))
   print(findall(re_str, 'a98ba89b'))
   

5.分支

1. |

   """
   正则1|正则2|正则3|..
   正则1匹配失败正则2再匹配依次匹配
   """
   
   # 写一个正则能够匹配一个字符串，abc后面是三个数字或者abc后面是三个大写字母
   re_str = r'abc\d{3}|abc[A-Z]{3}'
   print(fullmatch(re_str, 'abc123'))
   print(fullmatch(re_str, 'abcASD'))
   
   
   re_str = r'abc(\d|[A-Z]){3}'
   print(fullmatch(re_str, 'abc123'))
   print(fullmatch(re_str, 'abcASD'))
   

6.转义符号

"""
在正则中有特殊意义的符号前加\,让这个符号在正则中的功能消失
"""
re_str = r'\d{2}\.\d{2}\{}'
print(fullmatch(re_str, '12.21{}'))

# 注意：在正则中独立存在有特殊意义的符号，放到[]中，它的意义会自动消失
re_str = r'[-a]ab'
print(fullmatch(re_str, '-ab'))

re模块的使用

import re

# 1.re.compile(正则表达式)   -   编译正则表达式，返回正则对象
re_obj = re.compile(r'\d{3}')

# 正则表达式对象.fullmatch(字符串)
print(re_obj.fullmatch('789'))

# re.fullmatch(正则表达式,字符串)
print(re.fullmatch(re_obj, '879'))

# 2.匹配
"""
fullmatch(正则,字符串)   -   让整个字符串和正则进行匹配，匹配失败返回None，匹配成功返回对象
match(正则,字符串)   -   匹配字符串开头，失败返回None，成功返回对象
"""
print(re.match(r'\d{3}', '2343sdfdf'))

# 匹配对象
result = re.match(r'(\d{2})([a-z]{3})([A-Z]{2})', '34ghfDSdfdsfs')
print(result)
# 匹配到的子串
# 匹配对象.group()/匹配对象.group(0)  -   获取整个正则匹配到的子串
print(result.group())
print(result.group(1))
print(result.group(3))

# 2)获取匹配范围  -   匹配到的子串在原字符串的下标范围
# 匹配对象.span()
print(result.span())  # [0,7)
print(result.span(2))

# 3.查找
"""
search(正则,字符串)  -   在字符串中查找第一个满足正则的子串，如果找到了返回匹配对象，找不到返回None
findall(正则, 字符串)    -   获取字符串中所有满足正则的子串，返回值是列表，列表中的元素是字符串
                            找不到返回None
finditer(正则, 字符串)   -   获取字符串中所有满足正则的子串，返回值是迭代器，
                            迭代器中的元素是匹配对象
"""
# 没有分组
print(re.findall(r'\d{3}','afdsf1232dfdf231'))
# 有一个分组
print(re.findall(r'a(\d{3})','a223sdadsfa341'))
# 有两个或者两个以上的分组
print(re.findall(r'([a-z]{2})(\d{3})', 'ab123sdffdf34212sdkkdkf3'))

# 3) finditer
result = re.finditer(r'([a-z]{2})(\d{3})', 'ab123sdffdf34212sdkkdkf3')
print(list(result))

# 4.
"""
split(正则,字符串)   -   将字符串中满足正则的子串作为切割点

sub(正则, 字符串1,字符串2)  -   将字符串2中满足正则的字符串全部替换成字符串1
"""
result = re.split(r'\d+', 'ssa3fa432sdf31dfsf43dsfsf12')
print(result)

result = re.sub(r'[傻逼]', '*', '傻逼sa3fa432sdf31dfsf43dsfsf12')
print(result)