1⃣️正则表达式语法

正则表达式是用匹配或者描述字符串的工具

用处:
a.判断字符串是否满足某个条件---判断输入的字符串是否是/手机号码。是否是ip地址
b.提取满足条件的字符串
c.字符串替换

python中通过re模块中相应的方法来支持正则表达式的匹配、查找和替换等功能

from re import fullmatch

#fullmatch(正则表达式字符串, 字符串) --> 判断正则表达式和字符串是否完全匹配
#正则表达式字符串:就是一个字符串，字符串中是正则表达式语法。r'正则表达式'
#正则表达式中包含两个部分，一个是正则语法对应的字符，第二个是普通字符


# 1   .(匹配任意字符)


#一个.只匹配一个任意字符

# 匹配一个字长度是3的符串，第一个字符是'a',第二个字符是任意字符，最后一个字符是'b'
re_str = r'a.b'
print(fullmatch(re_str, 'adb'))

# 2  \w(匹配字母数字下划线)

#一个\w匹配一个字符


# 匹配第一个字符是数字或者下划线，后面三个字符是任意对象字符串
re_str1 = r'\w...'
print(fullmatch(re_str1, '08js'))
# 3\s(匹配任意空白字符)

#空白字符：空格、制表符、回车(执行)， 都输入空白符
#  匹配第一个字符是a，第二个字符是空白，最后一个字符b的字符串
re_str2 = r'a\sb'
print(fullmatch(re_str2, 'a b'))

# 4 \d(匹配数字字符)
re_str = r'\d\d\d'
print(fullmatch(re_str, '123'))

# 5 \b(检测边界)
#一个\b不回去匹配一个字符，而是单纯的检测\b出现的位置是否是单词边界
#单词边界:字符串开始和结尾、空格、换行、标点符号等，可以将两个单词隔开的字符都是单词边界
abc
re_str3 = r'\babc'
re_str = r'abc\b\saaa' # 匹配一个字符串前三位是abc，第四位是空白字符，后面是aaa。并且要求c后面是单词边界
result = fullmatch(re_str3, 'abc')
print(result)

# 6^(检测是否是字符串开头)
re_str = r'^\d\d\d+' # 判断一个字符串是否是三个数字开头
result = fullmatch(re_str, '221234')
print(result)
# 7 $(检测是否是字符串结尾)
re_str = r'\dabc$'
result =fullmatch(re_str, '1abc')
print(result)
# 8 \W(匹配第一个字符非数字字母下划线)
re_str = r'\Wabc'
result = fullmatch(re_str, '#abc')
print(result)

# 9 \S(匹配非空白字符)
re_str = r'\S...'
result = fullmatch(re_str, '12w2')
print(result)
# 10 \D(匹配非数字字符)
re_str = r'\D\w\w\w'
result = fullmatch(re_str, 'w12r')
print(result)

# 11 \B(检测是否不是单词边界)
re_str = r'ad\Bwr'
result = fullmatch(re_str, 'adwr')
print(result)

# 12 [](匹配中括号中出现的任意一个字符)

#一个中括号匹配一个字符
#[字符集] --> 匹配一个字符，这个字符是字符集中的任意一个字符
#[abc], [\d+]

#[字符1-字符2] -->匹配一个字符，这个字符是Unicode编码值在字符1到字符2中的任意字符
#[1-9] -->数字1到9  [a-z] -->小写字母 -->[A-Z] -->大写字母

#注意：-在中括号中，如果放在两个字符之间表示范围。

# 匹配一个第一个字符是a或者b或者c,后面aaa
re_str = r'[abc]+aaa'
result = fullmatch(re_str, 'caacaccaaa')
print(result)


re_str = r'[1-4]\d\d\d'
result = fullmatch(re_str, '1234')
print(result)


# 13 [^字符集](匹配一个不再字符集中的任意字符)

#注意：^必须放在中括号中的最前面才有效


re_str = r'[^abc]...'  # 匹配一个四位的字符串，第一位不是abc的任意一个，后面三位是任意字符
result = fullmatch(re_str, 'rqw2')
print(result)

2⃣️正则表达式次数相关的符号

from re import fullmatch

# 1 *(匹配0次或者多次)

"""
字符* --> 字符出现0次或者多次

"""
re_str = r'\d*'
print(fullmatch(re_str, '124'))

# 用正则表达式来检测一个标识符是否符合要求

re_str = r'[a-zA-Z_]\w*'
print(fullmatch(re_str, '_s1a12d'))

# 2  +(匹配一次或者多次)
# abc前面有一个或者多个数字的字符串
re_str = r'\d+abc'
print(fullmatch(re_str, '1abc'))

# 3.  ?(匹配0次或者一次)

re_str = r'a?123'
print(fullmatch(re_str, 'a123'))

# 练习：写一个正则表达式，匹配所有的整数
re_str = r'[+-]?[1-9]\d*'
print(fullmatch(re_str, '167'))
# 4. {}(指定次数)
"""
{N} --> 匹配N次
{M,N} --> 匹配M到N次
{M,} --> 至少匹配M次
{,N} --> 最多匹配N次
"""
re_str = r'\d{3,}'
print(fullmatch(re_str, '123'))

re_str = r'\d{2,5}'
print(fullmatch(re_str, '12233'))
# 判断密码是否符合要求：密码是有数字和字母组成，并且位数输6-16位
re_str = r'[0-9a-zA-Z]{6,16}'
print(fullmatch(re_str, '01231dddds.'))

三分之和组合

import re

# 1. |(分之)
"""
条件1|条件2 --> 先用条件1去匹配，如果匹配成功了。如果条件1匹配失败，用条件2去匹配。
注意：如果条件1匹配成功就不会用条件2再去匹配
"""
re_str = r'[a-z]{3}|[A-Z]{3}'
print(re.fullmatch(re_str, 'ASF'))

#

re_str = r'abc(H|K|L)'
print(re.fullmatch(re_str, 'abcK'))

# 2()(分组)
"""
a.组合(将括号中的类容作为一个整体进行操作)
b.捕获 --> 使用带括号的正则表达式匹配成功后，只获取括号中的内容
c.重复 --> 在正则表达式中可以通过\数字来重复前面()中匹配到的结果.数字代表前面的第几个分组
"""
# 2d3f4g 匹配一个字符串，以数字字母的组合出现三次
re_str = r'(\d[a-zA-Z]){3}'
print(re.fullmatch(re_str, '1o2i3i'))
print(re.findall(re_str, '1o1o1o'))

# c.重复
re_str = r'([a-z]{3})-\1'
print(re.fullmatch(re_str, 'asd-asd'))

# 3.转义符号
"""
正则表达式中可以通过在特殊的符号前加\，来让特殊的符号没有意义

. + * ? ^ $ 等有特殊的功能

⚠️注意：在中括号中有特殊功能的符号，只代表符号本身
        \ 不管在哪都需要转义
        - 在[]外面没有特殊功能，在[]中要表示-本身，就不要放在两个字符之间
        ()需要转义
"""
re_str = r'\.abc'

print(re.fullmatch(re_str, '.abc'))

4⃣️模块中的函数

import re
# 1. compile
"""
compile(正则表达式字符串) --> 将正则表达式字符串转换成正则表达式对象
"""
re_objct = re.compile(r'\d+')
print(re_objct)
print(re_objct.fullmatch('23738'))

# 2. fullmatch和match
"""
fullmatch(正则表达式字符串, 字符串) 
--> 用正则表达式去完全匹配字符串(匹配整个字符串)，返回匹配对象(SRE_Match)或者None

match(正则表达式字符串, 字符串)
--> 匹配字符串开头,返回匹配对象或者None
"""
result = re.fullmatch(r'\d([a-zA-Z]+)123', '2hjdh123')
print('111',result)
# 1.span(group=0) --> 获取匹配成功的区间(左闭右开区间)
print(result.span(z))
print(result.start(1))   # 获取匹配到的开始下标
print(result.end(1))     # 获取匹配到的结束下标后的下标

# 2.group(group = 0) --> 获取匹配结果
"""
group()/group(0) --> 获取正则表达式完全匹配的结果
group(index>0) --> 获取正则表达式中第group个分组匹配到的结果
"""
print('0:',result.group())
print('1:',result.group(1))
# 3.string --> 获取被匹配的原字符串
print(result.string)


result = re.match(r'\d([a-zA-Z]+)123', '2hjdh123ABC')
print('match:',result)


# 3.search
"""
search(正则表达式, 字符串)
--> 查找字符串中满足正则表达式的第一个字符串。返回值是匹配对象或者None
"""
result = re.search(r'(\d)[a-zA-Z]+', 'uhsh2hdje+984nf')
print(result.group(0))
print(result.group(1))
print(result.string)

# 练习：使用search匹配出一个字符串中所有的数字字符串
# 'abc34jshd8923jkshd9lkkk890k' --> 34，8923，9，890
re_str = r'\d+'
str1 = 'abc34jshd8923jkshd9lkkk890k'
result = re.search(re_str, str1)
while result:
    print(result)
    str1 = str1[result.end():]
    result = re.search(re_str, str1)

# 4.findall
"""
findall(正则表达式, 字符串) --> 获取字符串中满足正则表达式的所有的子串，返回一个列表
注意：如果正在表达式中有分组，取值的时候只取分组中匹配到的结果;
    如果有多个分组，会将每个分组匹配到的结果作为一个元祖的元素
"""
re_str = r'(\d+)k([a-d]+)'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.findall(re_str, str1)
print(result)  # [('8923', 'abc'), ('890', 'aa')]

re_str = r'(\d+)k[a-d]+'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.findall(re_str, str1)
print(result)  # ['8923', '890']

re_str = r'\d+k[a-d]+'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.findall(re_str, str1)
print(result)  # ['8923kabc', '890kaa']

# 5.finditer
"""
finditer(正则表达式, 字符串) 
--> 查找所有满足正则条件的子串，返回值是迭代器，迭代器中的元素是匹配对象
"""
re_str = r'\d+'
str1 = 'abc34kshd8923kabcshd9lkkk890kaa'
result = re.finditer(re_str, str1)
print(result)
for item in result:
    print(item)

# 6. split
"""
split(正则表达式,字符串) --> 将字符串按照满足正则表达式条件的子串进行分割
"""
str1 = 'ahsb1sssa8-jjhd7nhs+90nsjhf3-4hhh7+8kjj-'
result = re.split(r'[-+]', str1)
print(result)

# 7.sub
"""
sub(正则表达式,repl,字符串) --> 将字符串中满足正则表达式条件的子串替换成repl。返回替换后的字符串
"""
str1 = 'hsj8jskfh98ssjj8hshh'
result = re.sub(r'\d+','*', str1)
print(result)

str1 = '智      障,你在干嘛？逼, 后视镜，妈的加扣扣上'
result = re.sub(r'傻\s*叉|逼|fuck|妈的|智\s*障', '*', str1)
print(result)

5⃣️歌词解析

"""
需求：播放指定歌曲的时候，给一个时间，能够把这首歌在这个时间对应的词返回

面向对象：找一个类，让他拥有解析歌词的功能
"""


class Lyrics:
    # 歌词类
    def __init__(self, time='', word=''):
        self._time = time
        self.word = word

    def __repr__(self):
        return str(self.__dict__)

    @property
    def time(self):
        return self._time

    @time.setter
    def time(self, value):
        fen = float(value[1:3])
        miao = float(value[4:])
        self._time = fen * 60 + miao
    def __gt__(self, other):
        return self._time>other._time

class AnalysisLyric:
    # 歌词解析类
    def __init__(self, name):
        self.name = name  # 歌名
        self.all_lyric = []  # 保存当前解析出得歌词

    # 分离歌词和时间
    def __split_time_word(self, line):
        lines = line.split(']')
        # print(lines[-1])
        # 获取每一行的词
        word = lines[-1]
        # 便利获取每一行的时间
        for time in lines[:-1:]:
            # 根据时间和词创建歌词对象

            ly_obj = Lyrics(word=word)
            ly_obj.time = time
            self.all_lyric.append(ly_obj)
    # 根据时间获取歌词

    def get_lyrics(self, time: int):
        try:
            with open('./'+self.name+'.txt', 'r', encoding='utf-8') as f:
                line = f.readline()
                while line:
                    # print(line)
                    lyric = self.__split_time_word(line)
                    line = f.readline()

            self.all_lyric.sort(reverse=True)
            # print(self.all_lyric)
            for item in self.all_lyric:
                if item.time < time:
                    return item.word
        except FileNotFoundError:
            print('没有相应的歌词！')


lyh_ly = AnalysisLyric('蓝莲花')
print(lyh_ly.get_lyrics(17))