一些python 自定义函数

python 自定义函数

# 从字符串中截取两个关键字之间的字段且截取字段不包含第二个关键字，返回列表。
import re
def cut_out_str_by_2kw(s:str,kw1:str,kw2:str) -> list:
    '''
    更新于2021.05.13
    彡
    s为不含换行符和制表符的字符串。
    本函数用于从字符串中无重复地截取两个关键字之间的字段且截取字段不包含第二个关键字，返回列表，
    若关键字中有一个为空而另一个在字符串中，则空的关键字以非空关键字及字符串的前后两端为界，
    若关键字非空且不在字符串中则返回空列表。
    若关键字非空虽然在字符串中，但有连体现象或单个组反序，亦返回空列表。
    若两个关键字非空且相同，但是字符串中只出现一个关键字时，则会报错
    '''
    n2 = len(kw2)
    if kw1 + kw2 == '':
        return [s]
    elif kw1 == '':        
        #if s[-n2:] == kw2:
        #    pass
        #else:
        #    s = s + kw2
        li0 = []
        for i in re.findall(kw1+'.*?'+kw2,s):
            li0.append(i[:-n2])
        return li0
    elif kw2 == '':
        if s[-n2:] == kw2:
            pass
        else:
            s = s + kw1
        return cut_out_str_by_2kw(s,kw1,kw1)
    else:
        #if s[-n2:] == kw2:
        #    pass
        #else:
        #    s = s + kw2
        try:
            s = re.search(kw1+'.*'+kw2,s).group(0)#用贪婪取法取出可能区域，减少后期计算
            #s = re.findall(kw1+'.*'+kw2,s)[0]
            #在查询一个结果的条件下search与findall速度差不到
            li1 = re.search(kw1+'.*?'+kw2,s).group(0)[:-n2]#用非贪婪取法取出第一个符合要求的截断
            s = s[len(li1):]
            #print(li1)
            #print(li2)
            #print(m)
            #print(s)
            li2 = []
            li2.append(li1)
            return li2 + cut_out_str_by_2kw(s,kw1,kw2)
        except:
            return []

# strip()函数,默认删除空格和换行。可以加参数，但是只能删除开头或者结尾的字符。
# print(re.sub('\s|\t|\n','',str))  #\s代表空格，\t代表制表符，\n代表换行符

# 可监控程序运行时间
import time

def clock(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print("共耗时: %s秒" % round(end_time - start_time, 2))   # 2代表精度 时间值保留2位小数
        return result
    return wrapper

@clock
def test():
    time.sleep(0.5)
    print("test函数已执行")

if __name__ == "__main__":
    test()

import re
def isclose(s:str):#->bool:
    '''
    判断字符串是否符合闭合规则:
    一级闭合符号：""
    二级闭合符合：<>,[],{}
    1> 闭合指闭合符号按序出现，非按序出现的不能判断为闭合，如：}{ 不是闭合；
    2> 一级闭合符号内的一级闭合符号，如无转义将就近闭合，如："""中前两个"组成一个闭合，第三个"等待闭合；
    3> 一级闭合符号内的二级闭合符号可以不闭合；
    4> 二级闭合符号内的一级闭合符号在无转义下必须闭合；
    5> 二级闭合符号内的另一类二级闭合符号无论是否转义下都必须闭合。
    6> 同类二级闭合符号允许嵌套，如[[]]
    7> 不同类二级闭合符号不允许交叉，[<]>
    '''
    def last_one_or_empty_string(ss):
        try:
            rss = ss[-1]
        except:
            rss = ""
        return rss
    
    n = len(s)
    rs = False
    s_temp ='' # 前继的闭合符号的排列，用于排除交叉，注意它必须是一个序列！！
    is_cross = False
    d_record = {'\\':0, '"':0, '<':0, '>':0, '[':0, ']':0, '{':0, '}':0, '\"':0} # 该字典内闭合符合的数量是一增一消的。
    # print结果为：d_record = {'\\': 0, '"': 0, '<': 0, '>': 0, '[': 0, ']': 0, '{': 0, '}': 0} 即，实际上'"' = '\"'
    #print("d_record:",d_record)
    for i in range(n):
        #print(i)
        if (s[i] in ['\\','"', '<', '>', '[', ']', '{', '}']) and (is_cross == False):
            # 用len()可以判断 \是否对后面的字符转义了，如:len('\n')=1 , len('\y')=2，特别注意：len('\"')=1
            if (s[max(i-1,0)] != '\\') and (s[i] == '"' or s[i] == '\"') and (is_cross == False):
                d_record['"']+=1
                #s_temp += '"' # 更新前继的闭合符号
            elif (d_record['"']%2==0) and (is_cross == False):
                # 只有一级闭合符号："" 已经闭合(即，mod2 = 0)；后面对二级闭合符合：<>,[],{}的讨论才有意义：
                if s[i] == '<':
                    d_record['<']+=1
                    s_temp += '<' # 更新前继的闭合符号排列
                elif s[i] == '[':
                    d_record['[']+=1
                    s_temp += '[' # 更新前继的闭合符号排列
                elif s[i] == '{':
                    d_record['{']+=1
                    s_temp += '{' # 更新前继的闭合符号排列
                elif s[i] == '>':
                    if s[max(i-1,0)] == '-' and s[i] == '>':
                        # 对箭头"->"进行过滤
                        pass
                    else:
                        if d_record['<']>0 and s_temp[-1] == '<':
                            # 此时'<'必须是更新前继的闭合符号
                            d_record['<']-=1
                            s_temp = s_temp[:-1] # 更新前继的闭合符号排列
                        else:
                            is_cross = True # 出现交叉
                            break
                elif s[i] == ']':
                    if (d_record['[']>0) and (s_temp[-1] == '['):#(last_one_or_empty_string(s_temp) == '['):
                        d_record['[']-=1
                        s_temp = s_temp[:-1] # 更新前继的闭合符号排列
                    else:
                        is_cross = True # 出现交叉
                        break
                elif s[i] == '}':
                    if d_record['{']>0 and s_temp[-1] == '{':
                        d_record['{']-=1
                        s_temp = s_temp[:-1] # 更新前继的闭合符号排列
                    else:
                        is_cross = True # 出现交叉
                        break
    print("s_temp:",s_temp)
    print("d_record:",d_record)
    print("is_cross:",is_cross)
    if (is_cross == False) and (d_record['"']%2==0) and (d_record['<']==0) and (d_record['[']==0) and (d_record['{']==0):
        rs = True
    return rs


s_test = 'subgraph cluster_0 {label="Subgraph A{}\\}ft\\"\\""; a -> c; };'
s_test = 'subgraph cluster_0 {"{",{},[[{}]]}{[]}'#label="Subgraph A{}\\}ft\\"\\""; a -> c; };'
print(s_test)
print(len(s_test))
rs = isclose(s_test)
print(rs)