一个加密解密字串库 附带一个生产随机数的库

secret.py

import random

def shuffle(target:list,seed:int = None):
    #洗牌算法
    #https://www.jianshu.com/p/512fa876199b
    random.seed(seed)#设置随机数种子，默认不设置
    for change in range(len(target) - 1, 0, -1):
        lower = random.randint(0, change)
        target[lower], target[change] = target[change], target[lower]

class Seed:
    '''
    通过这个类可以得到一个随机数
    '''
    __seed = random.randint(1, 1000000)#产生初始的随机数种子
    __times = random.randint(1, 1000000)#循环次数
    __mode = 'random'#模式（参数随机模式）
    def __init__(self,seed:int=__seed,times:int=__times):
        self.seed = seed
        self.times = times
        self.mode = self.__mode
        if self.seed != self.__seed and self.times != self.__times:#如果参数为输入而非程序随机生成
            self.mode = 'input'#模式改为输入模式


    def lcg(self):
        #lcg算法
        #https://zhuanlan.zhihu.com/p/273230064
        self.seed = (25214903917 * self.seed) % ((1 << 48) - 1)
        return self.seed
    def _get_seedcode(self):
        #将 seed 和 times 合成一个新的数字作为密钥（种子码）
        number_of_seed = len(str(self.seed))#seed的位数
        number_of_times = len(str(self.times))#times的位数
        #将四个数字合在一起
        result = ''.join([str(self.__seed),str(self.__times),str(number_of_seed),str(number_of_times)])
        return result
    def get_seed(self):
        #得到一个随机数
        for i in range(self.times):
            #多次循环改变随机数种子
            self.lcg()
            if i == self.times-1:#最后一次循环
                result = self.lcg()#得到最后一个随机数
                if self.mode == 'random':#如果模式是随机模式
                    self.seed = self.__seed#此行意义如下
                    '''因为在函数lcg()中种子被不断地改变
                    所以在所有lcg()函数结束后将self.seed重新赋值'''
                    code = self._get_seedcode()#生成种子码
                    return [result, code]  # 返回随机数,以及对应的种子码
                elif self.mode == 'input':#如果是输入模式（种子码已给）
                    return result#只返回随机数

    def decrypt_seedcode(self,seedcode:str):
        #将密钥（种子码）解密为seed与times
        number_of_seed = int(seedcode[-2])#seed种子的位数
        number_of_times = int(seedcode[-1])#times次数的位数
        seed = seedcode[0:number_of_seed]#种子
        times = seedcode[-2-number_of_times:-2]#次数
        return [seed,times]

class Secret:

    class Encrypt:
        '''以下是支持的字符'''
        str1 = ' abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
        str2 = '~!@#$%^&*()_+`-={}|[]:;<>,.?/'
        str3 = "'"
        str4 = '"'
        string = str1 + str2 + str3 + str4
        lst = list(string)#所有元素的列表
        '''共94个元素'''
        def encrypt_random(self,string:str):
            #将字符串随机加密，返回结果和密钥
            lst_all = self.lst #即将打乱的字符串列表
            sd = Seed()
            seed = sd.get_seed()
            random_seed = seed[0]#随机数种子
            key = seed[1]#种子码(密钥)
            shuffle(lst_all,seed=random_seed)#打乱lst_all
            self.lst = list(self.string)#此行意义如下
            '''不知道为什么，对lst_all打乱后lst也被打乱了，于是重新赋值'''
            dic_lst = {key:value for key,value in zip(self.lst,lst_all) }#将lst与lst_all进行对应，生成字典
            lst_letter = []
            for i in string:#遍历字符串进行替换
                letter = dic_lst[i]#依次对应
                lst_letter.append(letter)#把结果依次添加进结果列表
            result = ''.join(lst_letter)#组合
            return [result,key]


    class Decrypt:
        '''以下是支持的字符'''
        str1 = ' abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
        str2 = '~!@#$%^&*()_+`-={}|[]:;<>,.?/'
        str3 = "'"
        str4 = '"'
        string = str1 + str2 + str3 + str4
        lst = list(string)  # 所有元素的列表
        '''共94个元素'''
        def Decrypt_random(self,string:str,key:str):
            #将加密的字符串解密
            sd = Seed()
            list_key=sd.decrypt_seedcode(key)#得到随机数属性列表（两个值：种子，次数）
            seed = list_key[0]#种子
            times = list_key[1]#次数
            sd = Seed(int(seed),int(times))#重新传入参数
            random_seed=sd.get_seed()#得到随机数种子
            lst_all = self.lst
            shuffle(lst_all, seed=random_seed)  # 打乱lst_all
            self.lst = list(self.string)  # 此行意义如下
            '''不知道为什么，对lst_all打乱后lst也被打乱了，于是重新赋值'''
            dic_lst = {key: value for key, value in zip( lst_all,self.lst)}  # 将lst与lst_all进行对应，生成字典
            lst_letter = []
            for i in string:  # 遍历字符串进行替换
                letter = dic_lst[i]  # 依次对应
                lst_letter.append(letter)  # 把结果依次添加进结果列表
            result = ''.join(lst_letter)  # 组合
            return result