python习题三道

Posted 2021-01-03

字典扁平化

目标  {‘a‘:{‘b‘;1,‘c‘:2},d:{‘e‘:3,f:{g:4}
期望  {‘a.b‘:1,‘a.c‘:2,‘d.e‘:4,‘d.f.g‘:4}
dic = {‘a‘:{‘b‘:1,‘c‘:2},‘d‘:{‘e‘:3,‘f‘:{‘g‘:4}}}
dic1 = {}
def fn(dic:dict,dic1key=‘‘):
        for k,v in dic.items():
                if isinstance(v,dict):
                        fn(v,dic1key=dic1key+ k +‘.‘)
                else:
                        dic1[dic1key + k] = v
fn(dic)
print(dic1)

base64编码

alphabet = b‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/‘

def base64encode(src:str):
        target = bytearray()
        if isinstance(src,str):
                ret = src.encode()
        else:
                return
        length = len(ret)

        r = 0  # 余下几个
        for offset in range(0,length,3):
                tripe = ret[offset:offset+3]
                if offset + 3 > length:
                        r = 3 - len(tripe)
                        tripe = tripe + b‘x00‘*r

                val = int.from_bytes(tripe,‘big‘)

                for i in range(18,-1,-6):
                        if i == 18:
                                index = val >> i
                        else:
                                index = val >> i & 0x3F
                        target.append(alphabet[index])
        for i in range(1,r+1):
                target[-i] = 61
        return bytes(target)

base64encode(‘a‘)

求最大公共字串

     矩阵算法
    str1 = ‘abcdef‘
    str2 = ‘defabcd‘
    def fn(str1:str,str2:str):
            if len(str1) > len(str2):
                    str1,str2 = str2 ,str1
            length1 = len(str1)  # 最短
            length2 = len(str2)

            matrix = [[0]*length1 for i in range(length2)]
            # print(matrix)

        xmax = 0
        xindex = 0

        for i,x in enumerate(str2):
                for j,y in enumerate(str1):
                        if x != y:
                                pass
                        else:
                                if i==0 or j==0:
                                        matrix[i][j] = 1
                                else:
                                        pre = matrix[i-1][j-1]
                                        if pre > 0:
                                                matrix[i][j] = pre + 1
                                if matrix[i][j] > xmax :
                                        xmax = matrix[i][j]
                                        xindex = j
        # print(matrix)
        # print(xmax, xindex)

        start= xindex + 1 -xmax
        end = xindex +1
        return str1[start:end]

print(fn(str1,str2))

装饰器的应用

实现一个cache装饰器，实现可过期被清除的可能
简化设计，函数的参数定义不包含可变位置参数，可变关键字参数和keyword-only参数
可以不考虑缓存满了之后的换出问题

from functools import wraps
import inspect
import time
import datetime

def mag_cache(fn):
        local_cache = {} #对不同函数名是不同的cache
        @wraps(fn)
        def wrapper(*args,**kwargs): #接收各种参数
                expire_keys = []
                for k,(_,stamp) in local_cache.items():
                        if (datetime.datetime.now().timestamp() - stamp) > 5:
                                expire_keys.append(k)
                for k in expire_keys:
                        local_cache.pop(k)

                # 参数处理，构建key
                sig = inspect.signature(fn)
                params = sig.parameters  # 有序字典
                params_dict = {}

                values = list(params.values())  #  有序的
                keys = list(params.keys())

                #位置传参
                # for i,x in enumerate(args):
                #     params_dict[keys[i]] = v
                params_dict.update(zip(params.keys(),args))
                #  关键字传参
                params_dict.update(kwargs)
                #  缺省值
                for k,v in params.items():# 定义的所有参数
                        if k not in params_dict:
                                params_dict[k] = v.default

                key = tuple(sorted(params_dict.items())) # 判断是否需要缓存
                print(key)

                if key not in local_cache.keys():
                        local_cache[key] = fn(*args,**kwargs),datetime.datetime.now().timestamp()
                return local_cache[key]
        return wrapper

@mag_cache
def add(x=4,y=5):
        time.sleep(3)
        return x+y

命令分发器

程序员可以方便的注册函数到某一个命令，用户输入命令时，路由到注册的函数
如果此命令没有对应的注册函数，执行默认函数
用户输入用input(">>")
def cmd_dispatcher(): #封装
        cmd_dict = {}

        def reg(cmd):
                def _reg(fn):
                        cmd_dict[cmd] = fn
                        return fn
                return _reg

        @reg(‘default_func‘)
        def default_func():
                print(‘default‘)
                return

        def dispatcher():
                while True:
                        cmd = input(‘>>‘)
                        if cmd == ‘quit‘:
                                return
                        cmd_dict.get(cmd, default_func)()

        return reg, dispatcher #封装

reg, dispatcher = cmd_dispatcher() #封装&解构

@reg(‘add‘)
def add(): #add=reg(‘add‘)(add)
        print(1)
        return

dispatcher()