我的创作纪念日

机缘

        我是一名初学者，因为未竟的学业，平常也暂时没有时间深入学习。我愿意成为一名“创作者”，更多的是想与大家分享我学习中的快乐，体悟程序之美。

        在越来越多文章背后，其实是一颗火热的心。

---

收获

        我最大的收获是，换一个角度、换一个场景向更多人分享我的知识、我的快乐。在写作过程中，我也因所涉理论而不断实践和打磨，收获了许多技术知识，变得日益熟练。     

        我十分感谢那些陪我和我的文章走过的知识与朋友，衷心祝愿你们都因为热爱知识聚在一起，哪怕只有每天几分钟时间在自己喜欢的领域里遨游，也能做自己的梦想家和实践家，在心海中泛舟，在荒园中耕锄......

---

日常

        创作悄然称为我生活和学习的一部分。于我来说，创作是一种精神状态，也是一种知识运用与巩固。但就目前来说，我的生活里，这些创作只分享了一小部分精力与时间。我希望在忙完这一阶段的事情以后，能花更多的时间学习Python和技术领域。

---

成就

说来惭愧，也没什么值得称赞的脚本，拿这个吧：

第一个是一个不成熟的想法，是一个数据处理器。当然，只能简单处理一维数组，形成算术平均数、方差等基础统计量。

import sys
import time
class main_:
    class system_:
        def login(users, psws, times:int):
            if times <= 5:
                times = 5
                time_lst = [10,10,30,60,120]
            elif times >= 10:
                times = 10
                time_lst = [10,10,10,10,10,30,30,30,60,120]
            code = 0
            for i in range(times * 2):
                user = input('请输入用户名。\n>>[').strip()
                if user in users:
                    pos = users.index(user)
                    print('用户名正确。')
                    code = 0
                    break
                else:
                    print('用户名不存在，请重试。')
                    if i >= times - 1 and code < len(time_lst):
                        print('用户名多次输入错误，请%s秒后重试。' % time_lst[code])
                        time.sleep(time_lst[code])
                        code += 1
                    elif i >= times - 1 and code == len(time_lst):
                        print('用户名多次输入错误，请退出重试。')
                        time.sleep(0.7)
                        sys.exit()
            for i in range(times * 2):
                psw = input('请输入密码。\n>>[').strip()
                if psw == psws[pos]:
                    print(f'密码正确。\n登陆成功。\n亲爱的用户 {user} ,欢迎您!\n\n')
                    break
                else:
                    print('密码错误，请重试。')
                    if i >= times - 1 and code < len(time_lst):
                        print('密码多次输入错误，请%s秒后重试。' % time_lst[code])
                        time.sleep(time_lst[code])
                        code += 1
                    if i >= times - 1 and code == len(time_lst):
                        print('密码多次输入错误，请退出重试。')
                        time.sleep(0.7)
                        sys.exit()
        def pack(users_ = None, psws_ = None):
            users = ['Rock Wang','Rex Wang','Karen Yao','Yuxi Chen','Yuhuan He']
            psws = ['-0854bhc378fxa5fdg9','g8e3xd8ff2i8j7d003','7805gig5xf3c3d9be8',
                    '25bh1jxha0786g0f7d','a0e-6ix0jg4h639j48e']
            if users_ and psws_:
                return users, psws
            if users_:
                return users
            if psws_:
                return psws
    class calculators:
        def ErrorRaiser(elements:list, weights = [0], ModeNoneCode = False):
            if len(elements) == len(set(elements)):
                ModeNoneCode = True
            try:
                elements = [eval(i) for i in elements]
            except:
                raise Exception('ValueError\n请勿输入不可转换的数据。\nRequire matching data, not an str.')
            
            if weights != [0]:
                if len(elements) == len(weights):
                    if len(elements) < 3:
                        raise Exception('QuantityError\n每一个列表都应该至少包含三个项。\nEach list should contain at least three elements.')
                    try:
                        weights = [eval(i) for i in weights]
                    except:
                        raise Exception('ValueError\n请勿输入不可转换的权重数值。\nRequire matching weight numbers, not str.')
                else:
                    raise Exception('''CorrespondingError\n请检查输入。\n每一个项目都应该有唯一位置上的对应权重。
Please check your inputs.\nEach element needs to matching its corresponding weight.''')
                return elements, weights, ModeNoneCode
            else:
                if len(elements) < 3:
                    raise Exception('QuantityError\n列表应该至少包含三个项。\nThe list should contain at least three elements.')
                return elements, ModeNoneCode
        def arithmetic_average(elements:list):
            aver = round(sum(elements) / len(elements), 3)
            return aver
        def weighted_average(elements:list, weights:list):
            aver = round(sum([element * weight for element, weight in zip(elements, weights)]) / sum(weights), 2)
            return aver
        def analysis_weighted_average(elements:list, weights:list):
            weighed_element = [(element, weight, round((element * weight)/sum(weights), 5)) for element, weight in zip(elements, weights)]
            aver = sum([value[2] for value in weighed_element])
            return weighed_element, aver
        def variance(elements:list, weights = None, aver_ = None):
            if aver_ == None:
                if weights == None:
                    aver = arithmetic_average(elements)
                else:
                    aver = weighted_average(elements, weights)
                variance = 1 / len(elements) * sum([(i-aver) ** 2 for i in elements])
                return round(variance, 3)
            else:
                if weights == None:
                    aver = aver_
                else:
                    aver = aver_
                variance = 1 / len(elements) * sum([(i-aver) ** 2 for i in elements])
                return round(variance, 3)
        def median(elements:list):
            num = len(elements)
            elements = sorted(elements)
            if num >= 3 and num % 2 == 0:
                median = round((elements[int(num / 2) - 1] + elements[int(num / 2)]) / 2, 2)
                return median
            else:
                median = elements[int((num - 1) / 2)]
                return median
        def mode(elements:list, ModeNoneCode = False):
            if ModeNoneCode == True:
                return '本组数据分布过于分散，众数不明显。\nNo obvious mode availible.', sorted(elements), set(elements)
            modes = [[0],[0]]
            time_list = [elements.count(i) for i in elements]
            for i in range(len(time_list) - 1):
                now = time_list[i]; next_ = time_list[i+1]
                if now >= next_:
                    if now > modes[0][0]:
                        modes[0].pop(0)
                        modes[1].pop(0)
                        modes[0].append(now)
                        modes[1].append(elements[i])
                        if len(time_list) - 1 == i + 1 and now == next_:
                            modes[0].append(next_)
                            modes[1].append(elements[i+1])
                    elif now == modes[0][0]:
                        modes[0].append(now)
                        modes[1].append(elements[i])
                        if len(time_list) - 1 == i + 1 and now == next_:
                            modes[0].append(next_)
                            modes[1].append(elements[i+1])
                        
            modes = list(set(modes[1]))
            modes.sort()
            if len(modes) == 1:
                modes = modes[0]
            return modes, sorted(elements), set(elements)
    class plotters:
        None
class inter:
    def main_inter():
        choice = input(f'''基础数据分析计算器 
Version 1.0
Summer Fruit All Rights Reserved.
Time Stamp: 
Authorization granted by author Summer Fruit.

{'*'*40}

您好，欢迎使用计算器。
祝您计算愉快。

功能：
（1）分析单组数据，计算其平均数、中位数、众数、方差。
（2）加权分析单组数据，计算其平均数、中位数、众数、方差。

请选择
>>[''')
        if '1' in choice:
            elements = input('''\n请输入数据列表，并用一个空格隔开每两个数据。\n输入空值以终止进程。
Please type the data list here.\nAnd separate every two numbers with a \'space\'
Type empty data to exit at anytime.\n>>[''').strip().split(' ')
            while elements != ['']:
                elements, ModeNoneCode = main_.calculators.ErrorRaiser(elements)
                aver = main_.calculators.arithmetic_average(elements)
                var = main_.calculators.variance(elements, weights = None, aver_ = aver)
                med = main_.calculators.median(elements)
                if ModeNoneCode == False:
                    mod, ordered_ele, set_ele = main_.calculators.mode(elements, ModeNoneCode)
                    mod = [mod,mod]
                else:
                    mod, ordered_ele, set_ele = main_.calculators.mode(elements, ModeNoneCode)
                    mod = mod.split('\n')
                print(f'''平均数: {aver}\n中位数: {med}\n众数: {mod[0]}\n方差: {var}
原始数据列表: {elements}\n有序数据列表: {ordered_ele}\n有序数据集合: {set_ele}\n\n
Average: {aver}\nMedian: {med}\nMode: {mod[1]}\nVariance: {var}
Original data list: {elements}\nOrdered data list: {ordered_ele}\nOrdered data set: {set_ele}
''')
                elements = input('\n请输入数据列表。\nType data list here.\n>>[').strip().split(' ')
                if elements == ['']:
                    break
        elif '2' in choice:
            elements = input('''\n请输入数据列表，并用一个空格隔开每两个数据。\n输入空值以终止进程。
Please type the data list here.\nAnd separate every two numbers with a \'space\'
Type empty data to exit at anytime.\n>>[''').strip().split(' ')
            weights = input('''\n请输入权重列表，并用一个空格隔开每两个数据。\n输入空值以终止进程。
Please type the weight list here.\nAnd separate every two numbers with a \'space\'
Type empty data to exit at anytime.\n>>[''').strip().split(' ')
            while elements != ['']:
                elements, weights, ModeNoneCode = main_.calculators.ErrorRaiser(elements, weights)
                aver = main_.calculators.arithmetic_average(elements)
                var = main_.calculators.variance(elements, weights, aver)
                med = main_.calculators.median(elements)
                if ModeNoneCode == False:
                    mod, ordered_ele, set_ele = main_.calculators.mode(elements, ModeNoneCode)
                    mod = [mod,mod]
                else:
                    mod, ordered_ele, set_ele = main_.calculators.mode(elements, ModeNoneCode)
                    mod = mod.split('\n')
                print(f'''平均数: {aver}\n中位数: {med}\n众数: {mod[0]}\n方差: {var}
原始数据列表: {elements}\n有序数据列表: {ordered_ele}\n有序数据集合: {set_ele}\n\n
Average: {aver}\nMedian: {med}\nMode: {mod[1]}\nVariance: {var}
Original data list: {elements}\nOrdered data list: {ordered_ele}\nOrdered data set: {set_ele}
''')
                elements = input('\n请输入数据列表。\nType data list here.\n>>[').strip().split(' ')
                if elements == ['']:
                    break
                        
users, psws = main_.system_.pack(True, True)
main_.system_.login(users, psws, 5)
inter.main_inter()

第二个是可爱的绘图：绘制正多边形。

import turtle as t
import random as ran
import math as m
import sys
import time as tm
class classic:
    def _init_(angle, radius, pencolor = 'black', bgcolor = 'white', pensize = 2, speed = 0):
        an = angle; r = radius
        t.hideturtle()
        t.pencolor(pencolor)
        t.bgcolor(bgcolor)
        t.pensize(pensize)
        t.speed(speed)
        t.pu()
        t.goto(0, r)
        t.seth(180)
        t.left(an / 2)
        t.pd()
    def get_side_lenth(radius, number_of_side):
        nos = number_of_side; r = radius
        ls = m.sin(m.radians(180 / nos)) * 2 * r
        return ls
    def get_exterior_angle(nos):
        an = 360 / nos
        return an
    def regular_triangle(ls, an):
        for i in range(3):
            t.forward(ls)
            t.left(an)
        print('正三角形(等边三角形)绘画完毕。\nDone.')
    def square(ls, an):
        for i in range(4):
            t.forward(ls)
            t.left(an)
        print('正四边形(正方形)绘画完毕。\nDone.')
    def regular_pentagon(ls, an):
        for i in range(5):
            t.forward(ls)
            t.left(an)
        print('正五边形绘画完毕。\nDone.')
    def regular_hexagon(ls, an):
        for i in range(6):
            t.forward(ls)
            t.left(an)
        print('正六边形绘画完毕。\nDone.')
    def regular_heptagon(ls, an):
        for i in range(7):
            t.forward(ls)
            t.left(an)
        print('正七边形绘画完毕。\nDone.')
    def regular_octagon(ls, an):
        for i in range(8):
            t.forward(ls)
            t.left(an)
        print('正八边形绘画完毕。\nDone.')
    def regular_nonagon(ls, an):
        for i in range(9):
            t.forward(ls)
            t.left(an)
        print('正九边形绘画完毕。\nDone.')
    def regular_decagon(ls, an):
        for i in range(10):
            t.forward(ls)
            t.left(an)
        print('正十边形绘画完毕。\nDone.')
    def regular_100_polygon(ls, an):
        for i in range(100):
            t.forward(ls)
            t.left(an)
        print('正一百边形绘画完毕。\nDone.')
class custom:
    changer = {3 : '三' , 4 : '四' , 5 : '五' , 6 : '六' , 7 : '七' ,
               8 : '八' , 9 : '九' , 10 : '十' , 100 : '一百'}
    def _error_raiser_(nos, radius, pensize, speed, pencolor, bgcolor):
        if type(nos) != int:
            print('下一次请输入一个整数。\nPlease input an integer next time.')
            sys.exit()
        if nos < 3:
            print('下一次请输入一个大于2的整数。\nPlease input an integer bigger than two next time.')
            sys.exit()
        if type(radius) != int:
            if type(radius) != float:
                print('下一次请输入一个数值作为半径。\nPlease input a number as the radius next time.')
                sys.exit()
        if type(pensize) != int:
            if type(radius) != float:
                print('下一次请输入一个数值作为画笔粗细。\nPlease input a number as the pen size next time.')
                sys.exit()
        if type(speed) != int:
            print('下一次请输入一个整数值作为画笔速度。\nPlease input an integer as the pen speed next time.')
            sys.exit()
        if type(pencolor) != str:
            print('下一次请输入一个有效字符串作为画笔颜色。\nPlease input a useful number as the pen color next time.')
            sys.exit()
        if type(bgcolor) != str:
            print('下一次请输入一个有效字符串作为画布颜色。\nPlease input a useful number as the background color next time.')
            sys.exit()
        #若半径为0或负数，则使用默认值180。
        if radius <= 0:
            radius = 180
        if pensize <= 0:
            pensize = 5
        if speed < 0:
            speed = 0
        if pencolor == 'default':
            pencolor = 'black'
        if bgcolor == 'default':
            bgcolor = 'white'
        return radius, pensize, speed, pencolor, bgcolor
    def _init_(angle, radius, pencolor = 'black', bgcolor = 'white', pensize = 25, speed = 0):
        an = angle; r = radius
        t.hideturtle()
        t.pencolor(pencolor)
        t.bgcolor(bgcolor)
        t.pensize(pensize)
        t.speed(speed)
        t.pu()
        t.goto(0, r)
        t.seth(180)
        t.left(an / 2)
        t.pd()
    def get_side_lenth(radius, number_of_side):
        nos = number_of_side; r = radius
        ls = m.sin(m.radians(180 / nos)) * 2 * r
        return ls
    def get_exterior_angle(nos):
        an = 360 / nos
        return an
    def custom_regular_polygon(number_of_side, lenth_of_side, angle, changer = changer):
        nos = number_of_side; ls = lenth_of_side; an = angle
        for i in range(nos):
            t.forward(ls)
            t.left(an)
        print(f'正{nos}边形绘画完毕。\nDone.')
class draw:
    class main_:
        def sample_mode(nos):
            if nos not in [3,4,5,6,7,8,9,10,100]:
                print('请检查您的输入。此边数不在样板之内。\nPlease check your inputs.It\'s not in samples.')
                sys.exit()
            ls = classic.get_side_lenth(180, nos)
            an = classic.get_exterior_angle(nos)
            classic._init_(angle = an, radius = 180)
            if nos == 3:
                classic.regular_triangle(ls, an)
            elif nos == 4:
                classic.square(ls, an)
            elif nos == 5:
                classic.regular_pentagon(ls, an)
            elif nos == 6:
                classic.regular_hexagon(ls, an)
            elif nos == 7:
                classic.regular_heptagon(ls, an)
            elif nos == 8:
                classic.regular_octagon(ls, an)
            elif nos == 9:
                classic.regular_nonagon(ls, an)
            elif nos == 10:
                classic.regular_decagon(ls, an)
            else:
                classic.regular_100_polygon(ls, an)
        def custom_mode(nos, radius, pensize, speed, pencolor, bgcolor):
            radius, pensize, speed, pencolor, bgcolor = custom._error_raiser_(nos, radius, pensize, speed, pencolor, bgcolor)
            ls = custom.get_side_lenth(radius, nos)
            an = custom.get_exterior_angle(nos)
            custom._init_(radius = radius, angle = an, pencolor = pencolor, bgcolor = bgcolor, pensize = pensize, speed = speed)
            custom.custom_regular_polygon(nos, ls, an)
    def example(nos, radius, pensize, speed, pencolor, bgcolor):
        custom._error_raiser_(nos, radius, pensize, speed, pencolor, bgcolor)
        ls = custom.get_side_lenth(radius, nos)
        an = custom.get_exterior_angle(nos)
        custom._init_(radius = radius, angle = an, pencolor = pencolor, bgcolor = bgcolor, pensize = pensize, speed = speed)    
        custom.custom_regular_polygon(nos, ls, an)
    def inter():
        choice = input('请选择绘画模式:\n(1)样板模式\n(2)自定义模式\n\nPlease select drawing mode:\n(1)default mode\n(2)DIY mode\n\n>>[')
        if '1' in choice:
            nos = input('''在此模式(样板模式)下，您可以选择预先设置好的正多边形绘图作为参考案例，下面是菜单：
In this mode (default mode), you can select the pre-set regular polygon drawing as a reference case. The following is the menu:
(1)正三角形(等边三角形)//regular triangle\n(2)正四边形(正方形)//square\n(3)正五边形//regular pentagon
(4)正六边形//regular hexagon\n(5)正七边形//regular heptagon\n(6)正八边形//regular octagon
(7)正九边形//regular nonagon\n(8)正十边形//regular decagon\n(9)正一百边形//regular polygon of 100 sides
请填写边数。\nPlease input the number of sides.\n>>[''').strip()
            try:
                nos = int(nos)
            except:
                print('请正确输入边数。\nPlease input the number correctly.')
                sys.exit()
            draw.main_.sample_mode(nos)
        else:
            nos = eval(input('请输入正多边形边数\nnumber of sides\n>>['))
            choice = input(f'边数nos：{nos}\n半径r：200\n画笔pen：5，black\n画布paper：white\n速度v：0\n请问是否需要更改参数？(Y/N)>>[').strip().upper()
            if 'Y' in choice:
                nos = eval(input('请输入正多边形边数\nnumber of sides\n>>['))
                radius = eval(input('请输入半径长度\nradius\n>>['))
                pensize = eval(input('请输入画笔粗细\npen size\n>>['))
                speed = int(input('请输入画笔速度\npen speed\n>>['))
                pencolor = input('请输入画笔颜色\npen colour\n>>[').strip().lower()
                bgcolor = input('请输入画布颜色\nbackground colour\n>>[').strip().lower()
            else:
                radius = 200; pensize = 5; speed = 0; pencolor = 'black'; bgcolor = 'white'
            draw.main_.custom_mode(nos, radius, pensize, speed, pencolor, bgcolor)
class recorder:
    def tm_changer(month):
        mon_dict = {1 : 'Jan.', 2 : 'Feb.', 3 : 'Mar.', 4 : 'Apr.',
                    5 : 'May', 6 : 'Jun.', 7 : 'Jul.', 8 : 'Aug',
                    9 : 'Sept.', 10 : 'Oct.', 11 : 'Nov.', 12 : 'Dec.'}
        return mon_dict[month]
    def timer():
        year, mon, day, hour, min_, s, wday, yday, isdst = tm.localtime()
        return f'{hour}:{min_}:{s}, {day} {tm_changer(mon)}'
    class write_in:
        def log(info):
            with open('system log for regular_polygon.py.txt','a+') as f:
                f.write(f'{info}\n\t{recorder.timer()}')
                f.close()
        def diary(info):
            with open('using diary for regular_polygon.py.txt','a+') as f:
                f.write(f'{info}\n\t{recorder.timer()}')
                f.close()
    class read:
        def log(info):
            with open('system log for regular_polygon.py.txt','a+') as f:
                log_read = f.read()
                return log_read
        def diary(info):
            with open('using diary for regular_polygon.py.txt','a+') as f:
                diary_read = f.read()
                return diary_read
if __name__ == '__main__':
    choice = input('欢迎使用正多边形绘图器，使用主功能请输入1，查看绘图范例请输入2。\n>>[')
    if '1' in choice:
        draw.inter()
    else:
        print('\n\n下面是调用示例:')
        #color = {0:'', 1:'', 2:'', 3:'', 4:''}
        for i in range(8):
            draw.example(10 - i, 200 - i * 20, 4, 10, 'white', 'gold')
        t.exitonclick()

#正多边形画图器 V3.5
#创建日期  3 Oct, 2022

最后是一个好玩的程序，自问自答的自助问答器，基础版本，只有问询功能。

import time
import os
class tmp:
    type_ = 'tmp_obj_set'
class examples:
    example_while_input = None

class Tools:
    def while_input(prompt:str = '',
                    while_ = True,
                    strip = True,
                    default_output:list = ['SystemRecord**未接收到内容**'],
                    ordinal_system = True,
                    ordinal_system_code = 1,
                    self = tmp):
        'ordinal system dict => {1: normal number range, 2: 汉字, 3: letters}'#逗你玩儿
        results = []

        
        if strip == True:
            strip_func = '.strip()'
        else:
            strip_func = ''   
        
        
        if while_ == True:
            prompt = f'{prompt}\n(1)'
            func = f'self.word = input(prompt){strip_func}'
            exec(func)
        
            count = 1
            while self.word.strip() != '':
                count += 1
                results.append(self.word)
                prompt = f'({count})'
                func = f'self.word = input(prompt){strip_func}'
                exec(func)
        else:
            func = f'self.word = input(prompt){strip_func}'
            exec(func)
            results.append(self.word)

            
        if len(results) > 1:
            if ordinal_system == True:
                results = ['(%s)%s'%(num,i) for i,num in zip(results,range(1,len(results)+1))]                
        if results == [] or ''.join(results).strip() == '':
            return default_output
        
        return results

    
def prepare():
    results = []
    key = '1'
    while key != '':
        name = input('请输入项目名称：')
        key = input('请输入对应提示语：')
        results.append(name)
        results.append(key)
    results.pop(-1)
    results.pop(-1)
    filename = input('请输入储存文件名称：')
    return results, filename

def ask(args):
    if len(args) % 2 != 0:
        raise Exception('ValueError\nThe arguments should be in pairs of two.')
    tm = [time.asctime()]
    arg_names = [args[num - 1] for num in range(1, len(args), 2)]
    arg_prompts = [args[num] for num in range(1, len(args), 2)]
    arg_pairs = {'记录时间':tm}
    for arg_name, arg_prompt in zip(arg_names, arg_prompts):
        prompt = '%s?' % arg_prompt
        arg_pairs[arg_name] = Tools.while_input(prompt)        
    return arg_pairs




def save_report(arg_pairs, file_name = 'Test'):
    tm = arg_pairs['记录时间'][0]
    tm2 = tm.replace(' ','-',tm.count(' ')).replace(':','_',tm.count(':'))
    filename = f"{file_name}.txt"
    with open(filename,'w') as f:
        content = zip(list(arg_pairs.keys()),list(arg_pairs.values()))
        for name, lst in content:
            f.write(f'{name}：\n\n')
            for val in lst:
                f.write(f'{val}\n')
            f.write('\n\n\n')
        f.close()
    return filename

def save_pack(arg_pairs):
    filename = 'packhere.txt'
    with open(filename,'a+') as f:
        f.write(str(arg_pairs)+'\n')
        f.close()
    return filename

def read_pack():
    filename = 'packhere.txt'
    with open(filename,'r') as f:
        content = f.readlines()
        f.close()
    if '\n' in content:
        content = content.remove('\n')
    content = [''.join(list(i)[:-1]) for i in content]
    dct = {num:item for num, item in zip(range(1, len(content) + 1), [eval(i) for i in content])}
    return dct

def inter():
    args, filename = prepare()
    arg_pairs = ask(args)
    report_name = save_report(arg_pairs, filename)
    pack_name = save_pack(arg_pairs)
    print(f'''\n\n\n数据报告已经生成，见工作路径下<<{report_name}>>文件。
数据包已经生成，见工作路径下<<{pack_name}>>文件。''')
    
if __name__ == '__main__':
    inter()


#Version: V.Test.1.0
#Create Date: 4 Feb, 2023

---

憧憬

计划于7、8月份密集学习和创作。