目標  {‘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()

python習題三道