3.24学习笔记

3.24学习笔记

一、正则匹配符号

from re import fullmatch

#1.什么是正则（正则表达式）
#正则是一种用来处理文本数据的一种工具。（一般用于处理复杂的文本问题）
#1）检测输入的数据是否是手机号
#2）检查输入的ip地址是否合法
#3）获取字符串中所有的数字数据：'sjhfj23世纪东方和79sk试试928sjd'
#……


#2.正则的语法 — 用不同的符号来描述字符串规则
#1）匹配类符号
#2）检测类符号
#3）控制次数的符号
#4）分组和分支
#5)其他常用参数
#fullmatch(正则表达式，字符串) — 检测字符串是否符合正则表达式描述的规则，如果不符合返回None
#'正则表达式' — Python          "正则表达式" — OC/Python         /正则表达式/ — js

#3.匹配类符号 — 一个符号对应字符串的一个字符
#1）普通字符 — 特殊符号以外的字符就是普通字符
#普通字符在正则中表示这个符号本身
re_str = 'abc'    #需要一个长度是3的字符串，并且第一个字符是a, 第二个字符是b, 第三个字符是c

#2）. — 匹配一个任意字符
re_str = 'a.c'   #需要一个长度是3的字符串，并且第一个字符是a，最后一个字符是c，中间是任意字符
print(fullmatch(re_str,'a胡c'))

re_str = '..ab'  # 一个长度是4的字符串，ab前面是任意两个字符
print(fullmatch(re_str, 'o9ab'))

#3）\d — 匹配任意一个数字字符
re_str = r'ab\d'    # 一个长度是3的字符串，ab后面是一个任意数字
print(fullmatch(re_str, 'ab3'))

#4）\w — 匹配任意一个数字、字母或者下划线（基于ASCII码）
re_str = r'w123'
print(fullmatch(re_str,'好123'))

#5)\s — 匹配任意一个空白字符
#空白字符 — 空格、\t、\n
re_str = r'123\sabc'
print(fullmatch(re_str, '123 abc'))

#6）\D、\S、\W
#\D — 匹配任意一个非数字字符
#\S — 匹配任意一个非空白字符
print(fullmatch((r'abc\S123\D','abcM123=')))

#7）[字符集] — 匹配字符集中的任意一个字符
"""
[ab12] — 匹配a、b、1、或2中任意一个字符
[ab\d]、[\dab]、[a\bd]、[ab0123456789] — 匹配a、b、或者0到9中任意一个字符
[0-9] — 匹配0到9中任意一个字符
[56789]、[5-9] — 匹配5到9中任意一个字符
[a-z] — 匹配任意一个小写字母
[A-Z] — 匹配任意一个大写字母
[a-zA-Z] — 匹配任意一个字母
[a-zA-Z\d] — 匹配任意一个字母、数字、下划线
[\u4e00-\u9fa5] — 匹配任意一个中文

注意：如果[]中-在两个字符之间表示范围，如果-不在2两个字符之间，它不具备特殊功能表示这个符号本身，-在[]外面也是普通符号
"""
re_str = r'a[xyz]b'
print(fullmatch(re_str,'ayb'))

print(fullmatch(r'abc[2-5]',abc4))

print(fullmatch(r'[\u4e00-\u9fa5]abc','好abc'))
# print(fullmatch(r'[z-a]abc', 'wabc'))   # 报错

#8)[^字符集] — 匹配除了字符集以外的任意一个字符
print(fullmatch(r'[^axy]','k123'))
print(fullmatch(r'[^a-zA-Z]123','-123'))

#注意：[]里面^只有放到最前面才有特殊意义，在其他位置表示^本身
print(fullmatch(r'[a-z^]123', '^123'))

二、检测类符号

from re import fullmatch, findall, search

#检测类符号在正则中不会影响字符串长度，它们的作用是在匹配成功以后检测检测类符号所在的位置是否符合要求
#1.\b — 检测是否是单词结尾
#单词结尾 — 凡是能够将两个单词区分开的所有的符号，主要有：空白、标点符号、字符串开头和字符结尾
re_str = r'abc\b123'
print(fullmatch(re_str,'abc 123'))

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

str1 = '数据集,890,shs323节省时间34jsj 922 失敬失8敬283'
result = findall(r'\b\d+\b', str1)
print(result)

#2.\B — 检测是否不是单词边界
result = findall(r'\B\d+\B', str1)
print(result)

#3.^ — 检测是否是字符串开头（[]外面）
#4.$ — 检测是否是字符串结尾（[]外面）
# re_str = r'^\dabc'
re_str = r'\dabc$'
print(findall(re_str, '7abc啥时间2abc数据9abc是6abc'))

三、匹配次数

from re import fullmatch, search, findall
import requests

#1.* — 匹配0次或者多次
"""
a* — 匹配0个或多个a
.*
\d*
[xyz]*
"""
re_str = r'a*123'
print(fullmatch(re_str,'aaaaaa123'))

re_str = r'.*123'
print(fullmatch(re_str, 'asc123'))

re_str = r'\d*abc'
print(fullmatch(re_str, '78908887abc'))

re_str = r'[xyz]*123'
print(fullmatch(re_str, 'xxyz123'))

#2.+ — 1次或者多次
#3.? — 0次或者1次
#4.{}
"""
{N} — 匹配N次
{M,N} — 匹配M~N次
{，N} — 匹配0~N次（最多N次）
{M，} — 匹配至少M次
"""
print(fullmatch(r'\d{3}abc{5}', '722abccccc'))
print(fullmatch(r'\d{3,5}abc', '72126abc'))
print(fullmatch(r'\d{,2}abc', '23abc'))
print(fullmatch(r'\d{2,}abc', '2231abc'))

#练习：写程序判断输入手机号是否合法：1）长度11位 2）都是数字  3）第一位必须是1，第二位是3~9
def is_tel(tel:str):
    result = fullmatch(r'1[3-9]\d{9}',tel)
    if result:
        print(f'{tel}是合法的手机号')
    else:
        print(f'{tel}不是合法的手机号')

is_tel('17886575434')

#5.贪婪和非贪婪
"""
贪婪和非贪婪模式是在匹配次数不确定的时候才会出现：*、+、?、{M,N}、{,N}、{M,}
贪婪和非贪婪：在能够匹配成功的情况下，如果对应的匹配次数有多种，贪婪模式选最多的那个次数，非贪婪选最少的那个次数。
贪婪：*?、+?、??、{M,N}?、{,N}?、{M,}?
"""
print(search(r'\d{3}','shsj234色即是空889====902'))

四、分支和分组

from re import fullmatch, findall

#1.分组 — ()
"""
应用一：将正则表达式中的一部分用（）括起来表示一个整体，然后进行整体相关操作
应用二：通过\M来重复它前面第M个分组匹配到的内容
应用三：捕获(获取结果的时候只取某个分组对应的内容)
"""

#hj78hu23kk90
re_str = r'([a-zA-Z]{2}\d\d){3}'
print(fullmatch(re_str,'hj78hu23kk90')

re_str = r'(\d{2})([A-Z]{3})\1{2}\2'
print(fullmatch(re_str,'12KAM1212KAM'))

re_str = r'[a-z]\(\d{3})'
result = findall(re_str,'hsjs234失敬失敬你a8393sjjk9901霎时间---234看看吗238')
print(result)

#2.分支 — |
#正则1|正则2
#|相当于或者
#abc123、abcMN
re_str = r'abc\d{3}|abc[A-Z]{2}'
print(fullmatch(re_str,'abcMN'))

re_str = r'abc\d{3}|[A-Z]{2}'
print(fullmatch(re_str,'MK'))

re_str = r'abc(\d{3}|[A-Z]{2})'
print(fullmatch(re_str,'abc234'))

五、re模块

from re import *

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

print(fullmatch(r'\d{3}', '234'))
print(re_obj.fullmatch('384'))

# 2. 匹配相关方法
# 1）fullmatch(正则表达式, 字符串)   -   完全匹配，判断整个字符串是否符合正则表达式描述的规则。如果不符合返回None,如果符合返回匹配对象
# 2）match(正则表达式, 字符串)   -   匹配开头，判断字符串开头是否符合正则表达式描述的规则。如果不符合返回None,如果符合返回匹配对象
re_str = r'[a-z]{3}'
print(fullmatch(re_str, 'hsm'))
print(match(re_str, 'mks结束的发就好为34'))

# 3）匹配对象
re_str = r'((\d{2})([A-Z]{3}))'
result = match(re_str, '23KLA失敬失敬')
print(result)    # <re.Match object; span=(0, 5), match='23KLA'>
# a.
# 匹配对象.group() / 匹配对象.group(0)  - 获取整个正则匹配到的内容
# 匹配对象.group(N)  - 获取正则表达式第N个分组匹配到的内容
print(result.group())     # '23KLA'
print(result.group(1))    # '23KLA'
print(result.group(2))      # '23'
print(result.group(3))      # 'KLA'

# b.
# 匹配对象.span() / 匹配对象.span(0)   -  获取整个正则匹配到的内容在原字符串中的位置信息(开始下标和结束下标)
# 匹配对象.span(N)  -   获取正则表达式第N个分组匹配到的内容在原字符串中的位置信息
print(result.span())
print(result.span(3))

# c.匹配对象.string  - 获取原字符串
print(result.string)   # '23KLA失敬失敬'

# 3. 查找相关方法
# 1) search(正则表达式, 字符串)  -   在字符串中搜索第一个满足正则表达式的字符串。如果找不到返回None，找到了返回匹配对象
print(search(r'\d{3}', '试试234节省时间988开始时间210'))    # <re.Match object; span=(2, 5), match='234'>

# 2) findall(正则表达式, 字符串)    -   获取字符串中所有满足正则表达式的子串。返回值是列表，如果找不到返回空列表
print(findall(r'\d{3}', '试试234节省时间988开始时间210'))    # ['234', '988', '210']
print(findall(r'\d{3}[\u4e00-\u9fa5]', '试试234节省时间988开始时间210mn'))   # ['234节', '988开']
print(findall(r'(\d{3})[\u4e00-\u9fa5]', '试试234节省时间988开始时间210mn'))   # ['234', '988']
print(findall(r'\d{3}-[a-z]{2}', '啥时间233-ks试试，892-mk啥，sjs2912-op'))  # ['233-ks', '892-mk', '912-op']
print(findall(r'(\d{3})-([a-z]{2})', '啥时间233-ks试试，892-mk啥，sjs2912-op'))   # [('233', 'ks'), ('892', 'mk'), ('912', 'op')]
print(findall(r'(\d[a-z]){3}', '是计算机上8m9l0b,s数据是8a0p1k'))    # ['0b', '1k']

# 3) finditer(正则表达式, 字符串)   - 获取字符串中所有满足正则表达式的子串。返回一个迭代器，迭代器中的元素是匹配对象
result = finditer(r'(\d{3})-([a-z]{2})', '啥时间233-ks试试，892-mk啥，sjs2912-op')
# print([x.group() for x in result])    # ['233-ks', '892-mk', '912-op']
# print([x.group(1) for x in result])     # ['233', '892', '912']
print([x.group(2) for x in result])       # ['ks', 'mk', 'op']

# 4) sub(正则表达式, 字符串1, 字符串2)  - 将字符串2中所有满足正则的子串全部替换成字符串
str1 = 'how are you? I am fine, Thank you!'
result = sub(r'you', 'me', str1)
print(result)    # how are me? I am fine, Thank me!

str1 = 'how are you? I am fine, Thank you!'
result = sub(r'you|I', 'me', str1)
print(result)   # how are me? me am fine, Thank me!

result = sub(r'傻[\s/,.\\]*[b瓜]|f\s*u\s*c\s*k|操', '*', r'我操， 你是傻    /b吗？F u c k')
print(result)

# 5) split(正则表达式, 字符串)  - 将字符串中所有满足正则表达式的子串作为切割点对字符串进行切割
result = split(r'[-+]', '试试-j234ss+skskj-健康是390福+世纪东2方看019计算机')
print(result)

result = split(r'\d+', '试试-j234ss+skskj-健康是390福+世纪东2方看019计算机')
print(result)

六、转义符号和参数

from re import fullmatch, I, S

# 1.转义符号   -  将在正则中有特殊功能或者意义的符号变成一个普通字符
# \具有特殊意义的符号: \.、\+、\*、...

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

re_str = r'\\dabc\+'
print(fullmatch(re_str, '\dabc+'))

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

# 将独立存在具备特殊功能的符号放在[]里面，这个符号的功能会自动消失
# 特别注意符号在[]里面也有特殊功能的情况，比如：^、-、[、]
re_str = r'\d{2}[.+?*(\-)|$^\]]\d{2}'
print(fullmatch(re_str, '23]34'))

# 2. 常用参数
# 1）忽略大小写
re_str = r'123[a-z]'

# 默认不忽略大小写
print(fullmatch(re_str, '123k'))   # <re.Match object; span=(0, 4), match='123k'>
print(fullmatch(re_str, '123M'))   # None

# 用法一： r'(?i)正则表达式'
re_str = r'(?i)123[a-z]'
print(fullmatch(re_str, '123k'))   # <re.Match object; span=(0, 4), match='123k'>
print(fullmatch(re_str, '123M'))    # <re.Match object; span=(0, 4), match='123M'>

# 用法一：
re_str = r'123[a-z]'
print(fullmatch(re_str, '123M', flags=I))    # <re.Match object; span=(0, 4), match='123M'>

# 2) 单行匹配
"""
多行匹配(默认)  -  表示任意字符的.不能和\n(换行符)进行匹配
单行匹配    -   表示任意字符的.可以和\n(换行符)进行匹配
"""
re_str = r'abc.123'
print(fullmatch(re_str, 'abc\n123'))    # None

# 用法一：
re_str = r'(?s)abc.123'
print(fullmatch(re_str, 'abc\n123'))   # <re.Match object; span=(0, 7), match='abc\n123'>

# 用法二：
re_str = r'abc.123'
print(fullmatch(re_str, 'abc\n123', flags=S))   # <re.Match object; span=(0, 7), match='abc\n123'>

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

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