分享一个自己做的模块

考不好不改名

不废话，代码如下：

# 文档
'''
- 这个模块的作者·SYZ·于·公元2021年2月27日·学习了密码学的相关知识后开始制作这个·用以加解密·的模块，并于·当天· 竣工* 。

* 换字式密码部分开发存在困难，目前未竣工


- 作者希望被使用的 接口* 如下：
    - KaiSa(s, n)
    - aKaiSa(s, n)

    - ZhaLan(s, n)
    - aZhaLan(s, n)

    - ZhuanZhi(s, n)
    - aZhuanZhi(s, n)

    - split(s, f, n, *i)

    - allin(s, n)
    - aallin(s, n)

    * 更多帮助参见其文档

- 用以辅助模块制作的内容现可以被使用的 接口* 如下：
    - mchr(n)
    - get_list(lenth, seed = 5)

    - class Square
        - __init__(self, width, height, filler)

    - test()

    * 以上接口可能没有文档

- 可以正常使用的接口已全部列举，使用未列举的接口可能导致模块不可用。


                                        ——SYZ
'''

# 辅助函数
def mchr(n):
    if n >= 0x110000:
        return chr(n - 0x110000)
    elif n < 0:
        return chr(n + 0x110000)
    else:
        return chr(n)
def get_list(lenth, seed = 5):
    r = []
    import random as m
    m.seed(seed)
    l = tuple(range(lenth))
    n = set()
    for i in range(lenth):
        while True:
            t = m.choice(l)
            if t in n:
                continue
            break
        r += [t]
        n.add(t)
    return r

# 凯撒密码
def KaiSa(s, n):
    '''
    - KaiSa(s, n)

    - 使用凯撒密码加密字符串s，以字符串返回密文，整数n表示将通用编码增大的长。
    - 使用模块内aKaiSa函数解密。
    '''
    r = ''
    for each in s:
        r += mchr(ord(each) + n)
    return r
def aKaiSa(s, n):
    '''
    - aKaiSa(s, n)

    - 解密被模块内KaiSa函数加密的字符串s，以字符串返回明文，整数n是当初传给KaiSa函数的第二个参数。
    '''
    return KaiSa(s, -n)

# 栅栏密码
def ZhaLan(s, n):
    '''
    - ZhaLan(s, n)

    - 使用栅栏密码加密字符串s，以字符串返回密文，整数n表示每组字符的个数。
    - 使用模块内aZhaLan函数解密。
    '''
    r = ''
    for i in range(n):
        while True:
            try:
                r += s[i]
            except IndexError:
                break
            i += n
    return r
class Square:
    def __init__(self, width, height, filler):
        self.width = width
        self.height = height
        self.dat = [[filler for i in range(width)] for i in range(height)]
    def set_dat(self, pos, value):
        self.dat[pos[1]][pos[0]] = value
    def get_dat(self, x, y):
        return self.dat[y][x]
    def iter_x(self, x):
        for y in range(self.height):
            yield self.get_dat(x, y), (x, y)
    def iter_y(self, y):
        for x in range(self.width):
            yield self.get_dat(x, y), (x, y)
    def iter_by_right(self):
        for y in range(self.height):
            for x in range(self.width):
                yield self.get_dat(x, y), (x, y)
    def iter_by_down(self):
        for x in range(self.width):
            for y in range(self.height):
                yield self.get_dat(x, y), (x, y)
def aZhaLan(s, n):
    '''
    - aZhaLan(s, n)

    - 解密被模块内ZhaLan函数加密的字符串s，以字符串返回明文，整数n是当初传给ZhaLan函数的第二个参数。
    '''
    if len(s) % n:
        r = ''
        t = Square(n, len(s) // n + 1, '')
        p = 0
        i = t.iter_by_down()
        for each in i:
            if each[1][1] == t.height - 1 and each[1][0] >= len(s) % n:
                continue
            try:
                t.set_dat(each[1], s[p])
            except IndexError:
                break
            p += 1
        i = t.iter_by_right()
        for each in i:
            r += each[0]
        return r
    else:
        return ZhaLan(s, n)

# 换字式密码

# 转置式密码
def ZhuanZhi(s, n):
    '''
    - ZhuanZhi(s, n)

    - 使用转置式密码加密字符串s，以字符串返回密文，整数n表示随机的种子。
    - 使用模块内aZhuanZhi函数解密。
    '''
    r = ''
    l = get_list(len(s), n)
    for i in l:
        r += s[i]
    return r
def aZhuanZhi(s, n):
    '''
    - aZhuanZhi(s, n)

    - 解密被模块内ZhuanZhi函数加密的字符串s，以字符串返回明文，整数n是当初传给ZhuanZhi函数的第二个参数。
    '''
    r = ''
    d = {}
    l = get_list(len(s), n)
    for i in range(len(s)):
        d[l[i]] = i
    for i in range(len(s)):
        r += s[(d[i])]
    return r

# 分割分别编译
def split(s, f, n, *i):
    '''
    - split(s, f, n, *i)

    - 循环以收集参数i为步长分割字符串s，分别以分割后的各部分为第一个参数、整数n为第二个参数传给 函数f* 处理，返回各次处理所得字符串按顺序拼接的字符串。
    * 应为模块内可用加解密函数，不保证非模块内可用加解密函数的运行结果
    '''
    while sum(i) < len(s):
        i *= 2
    while sum(i) > len(s):
        i = i[0:len(i) - 1]
    if sum(i) != len(s):
        i += (len(s) - sum(i),)
    r = ''
    p = 0
    for each in i:
        r += f(s[p:p + each], n)
        p += each
    return r

# 复合可用密码
def allin(s, n):
    '''
    - allin(s, n)

    - 复合模块内全部可用加密函数* 加密字符串s，以字符串返回密文，整数n表示将传给各个子函数的第二个参数。
    - 使用模块内aallin函数解密。
    * 先后复合函数KaiSa、ZhaLan、ZhuanZhi
    '''
    return split(split(split(s, KaiSa, n, 5, 6, 7, 8, 9), \
                       ZhaLan, n, 5, 6, 7, 8, 9), \
                 ZhuanZhi, n, 5, 6, 7, 8, 9)
def aallin(s, n):
    '''
    - aallin(s, n)

    - 解密被模块内allin函数加密的字符串s，以字符串返回明文，整数n是当初传给allin函数的第二个参数。
    '''
    return split(split(split(s, aZhuanZhi, n, 5, 6, 7, 8, 9), \
                       aZhaLan, n, 5, 6, 7, 8, 9), \
                 aKaiSa, n, 5, 6, 7, 8, 9)

# 模块测试
def test():
    s = '中文字符 EnglishLetters 0123456789 ~!@#$%^&*()_+\n'
    if s == aallin(allin(s, 5), 5):
        return True
    return False
if __name__ == '__main__':
    if test():
        print('Usual')
    else:
        print('Unusual')